SerialPortOsdpConnection.cs

using System;
using System.Collections.Generic;
using System.IO.Ports;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
 
namespace OSDP.Net.Connections
{
    public class SerialPortOsdpConnection : OsdpConnection, IRetunableOsdpConnection
    {
        private static readonly TimeSpan OpenRetryTimeout = TimeSpan.FromSeconds(1);
        private static readonly TimeSpan OpenRetryInterval = TimeSpan.FromMilliseconds(25);
 
        private readonly string _portName;
        private SerialPort _serialPort;

        public static readonly int[] StandardBaudRates = [9600, 19200, 38400, 57600, 115200, 230400, 460800];

        public SerialPortOsdpConnection(string portName, int baudRate) : base(baudRate)
        {
            _portName = portName ?? throw new ArgumentNullException(nameof(portName));
        }

        public static IEnumerable<SerialPortOsdpConnection> EnumBaudRates(string portName, int[] rates = null)
        {
            return (rates ?? StandardBaudRates).Select(rate => new SerialPortOsdpConnection(portName, rate));
        }

        public bool DiscardBuffersBeforeWrite { get; set; } = true;

        public override async Task Open()
        {
            if (_serialPort != null) return;
 
            var deadline = DateTime.UtcNow + OpenRetryTimeout;
            while (true)
            {
                var serialPort = new SerialPort(_portName, BaudRate);
                try
                {
                    serialPort.Open();
                    _serialPort = serialPort;
                    IsOpen = true;
                    return;
                }
                catch (UnauthorizedAccessException) when (DateTime.UtcNow < deadline)
                {
                    serialPort.Dispose();
                }
                catch
                {
                    serialPort.Dispose();
                    throw;
                }
 
                await Task.Delay(OpenRetryInterval).ConfigureAwait(false);
            }
        }

        public void SetBaudRate(int baudRate)
        {
            if (baudRate <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(baudRate), "Baud rate must be greater than zero.");
            }
 
            BaudRate = baudRate;
 
            var serialPort = _serialPort;
            if (serialPort != null && serialPort.IsOpen)
            {
                serialPort.BaudRate = baudRate;
            }
        }

        public async Task WaitForTransmitCompleteAsync(int frameByteCount, CancellationToken token = default)
        {
            var serialPort = _serialPort;
            if (serialPort == null || !serialPort.IsOpen) return;
 
            while (!token.IsCancellationRequested && serialPort.BytesToWrite > 0)
            {
                await Task.Delay(1, token).ConfigureAwait(false);
            }
 
            if (frameByteCount <= 0) return;
 
            var wireTime = TimeSpan.FromSeconds(frameByteCount * 10.0 / BaudRate);
            await Task.Delay(wireTime, token).ConfigureAwait(false);
        }

        public override Task Close()
        {
            _serialPort?.Close();
            _serialPort?.Dispose();
            _serialPort = null;
            IsOpen = false;
            return Task.CompletedTask;
        }

        public override async Task WriteAsync(byte[] buffer)
        {
            if (DiscardBuffersBeforeWrite)
            {
                // Found an issue where many timeouts would fill up the receive buffer.
                // When writing to the port, there should be nothing in the buffers.
                _serialPort.DiscardInBuffer();
                _serialPort.DiscardOutBuffer();
            }
 
            await _serialPort.BaseStream.WriteAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
        }

        public override async Task<int> ReadAsync(byte[] buffer, CancellationToken token)
        {
            var task = _serialPort.BaseStream.ReadAsync(buffer, 0, buffer.Length, token);
 
            if (await Task.WhenAny(task, Task.Delay(-1, token)) == task)
            {
                return await task.ConfigureAwait(false);
            }
 
            throw new TimeoutException();
        }

        public override string ToString()
        {
            return _portName;
        }
    }
}