LineQualityProtocol.cs

using System;
using System.Collections.Generic;
 
namespace OSDP.Net.LineQuality
{
    public static class LineQualityProtocol
    {
        internal static readonly byte[] VendorCodeBytes = { 0x02, 0x00, 0x0A };

        public const byte TestAddress = 0x7D;

        public const byte EchoCommandId = 0x01;

        public const byte BaudRateChangeCommandId = 0x02;

        public const int EchoHeaderLength = 7;

        public const int MaxPayloadLength = 113;

        public static IReadOnlyList<int> TestPayloadLengths { get; } = new[] { 0, 48, MaxPayloadLength };
 
        private static readonly int[] BaudRateValues =
            { 9600, 19200, 38400, 57600, 115200, 230400, 460800 };

        public static IReadOnlyList<int> DefaultBaudRates { get; } =
            new[] { 9600, 19200, 38400, 57600, 115200, 230400 };

        public static ReadOnlySpan<byte> VendorCode => VendorCodeBytes;

        public static bool IsLineQualityVendorCode(ReadOnlySpan<byte> candidate)
        {
            if (candidate.Length < VendorCodeBytes.Length) return false;
 
            for (int index = 0; index < VendorCodeBytes.Length; index++)
            {
                if (candidate[index] != VendorCodeBytes[index]) return false;
            }
 
            return true;
        }

        public static byte[] GeneratePattern(TestPattern pattern, int length)
        {
            if (length < 0 || length > MaxPayloadLength)
            {
                throw new ArgumentOutOfRangeException(nameof(length),
                    $"Payload length must be between 0 and {MaxPayloadLength}.");
            }
 
            if (!IsSupportedPattern(pattern))
            {
                throw new ArgumentOutOfRangeException(nameof(pattern), $"Unknown test pattern {pattern}.");
            }
 
            var data = new byte[length];
            for (int index = 0; index < length; index++)
            {
                data[index] = ExpectedByte(pattern, index);
            }
 
            return data;
        }

        public static bool ValidatePattern(TestPattern pattern, ReadOnlySpan<byte> data)
        {
            if (!IsSupportedPattern(pattern)) return false;
 
            for (int index = 0; index < data.Length; index++)
            {
                if (data[index] != ExpectedByte(pattern, index)) return false;
            }
 
            return true;
        }

        public static bool IsSupportedPattern(TestPattern pattern) => pattern <= TestPattern.WalkingOne;

        public static int ToBaudRate(LineQualityBaudRate baudRateId)
        {
            // The enum is byte-backed, so the index cannot be negative.
            int index = (int)baudRateId;
            if (index >= BaudRateValues.Length)
            {
                throw new ArgumentOutOfRangeException(nameof(baudRateId), $"Unknown baud rate ID {baudRateId}.");
            }
 
            return BaudRateValues[index];
        }

        public static bool TryGetBaudRateId(int baudRate, out LineQualityBaudRate baudRateId)
        {
            for (int index = 0; index < BaudRateValues.Length; index++)
            {
                if (BaudRateValues[index] != baudRate) continue;
 
                baudRateId = (LineQualityBaudRate)index;
                return true;
            }
 
            baudRateId = default;
            return false;
        }

        public static int IterationsPerCombination(TestProfile profile)
        {
            switch (profile)
            {
                case TestProfile.Screening: return 10;
                case TestProfile.Qualification: return 60;
                case TestProfile.Extended: return 200;
                default:
                    throw new ArgumentOutOfRangeException(nameof(profile), $"Unknown test profile {profile}.");
            }
        }

        public static double DetectionLimitPercent(int packetsSent) =>
            packetsSent <= 0 ? 100.0 : 300.0 / packetsSent;

        public static TimeSpan TransmissionTime(int byteCount, int baudRate) =>
            baudRate <= 0
                ? TimeSpan.Zero
                : TimeSpan.FromSeconds(byteCount * 10.0 / baudRate);
 
        internal static byte ExpectedByte(TestPattern pattern, int index)
        {
            switch (pattern)
            {
                case TestPattern.AllZeros: return 0x00;
                case TestPattern.AllOnes: return 0xFF;
                case TestPattern.AlternatingA: return 0xAA;
                case TestPattern.Alternating5: return 0x55;
                case TestPattern.Sequential: return (byte)(index & 0xFF);
                case TestPattern.WalkingOne: return (byte)(1 << (index % 8));
                default: return 0x00;
            }
        }
    }
}