using JiShe.CollectBus.Common.Enums;
using JiShe.CollectBus.Common.Models;
using System;
using System.Collections.Generic;
using System.Data.SqlTypes;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace JiShe.CollectBus.Common.BuildSendDatas
{
    /// <summary>
    /// 构建下发报文
    /// </summary>
    public static class TelemetryPacketBuilder
    {
        /// <summary>
        /// 构建报文的委托
        /// </summary>
        /// <param name="address"></param>
        /// <param name="fn"></param>
        /// <param name="pn"></param>
        public delegate byte[] AFNDelegate(string address, int fn, int pn = 0);

        /// <summary>
        /// 编码与方法的映射表
        /// </summary>
        public static readonly Dictionary<string, AFNDelegate> AFNHandlers = new();

        static TelemetryPacketBuilder()
        {
            // 初始化时自动注册所有符合命名规则的方法
            var methods = typeof(TelemetryPacketBuilder).GetMethods(BindingFlags.Static | BindingFlags.Public);
            foreach (var method in methods)
            {
                if (method.Name.StartsWith("AFN") && method.Name.EndsWith("_Send"))
                {
                    // 提取编码部分（例如 "AFN0D_F184_Send" -> "0D_184"）
                    string code = method.Name[3..^5].Replace("F", ""); // 移除前缀和后缀，替换F为_
                    var delegateInstance = (AFNDelegate)Delegate.CreateDelegate(typeof(AFNDelegate), method);
                    AFNHandlers[code] = delegateInstance;
                }
            }
        }

        #region AFN_00H 确认∕否认
        public static byte[] AFN00_F1_Send(string address,int fn,int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.确认或否认,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN00_F3_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.确认或否认,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }
        #endregion


        #region AFN_01H 复位命令
        public static byte[] AFN01_F1_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.复位,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }
        #endregion


        #region AFN_02H 链路接口检测
        public static byte[] AFN02_F2_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }
        #endregion

        #region AFN_04H 设置参数
        public static byte[] AFN04_F3_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN04_F10_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN04_F66_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN04_F88_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }
        #endregion

        #region AFN_05H 控制命令
        public static byte[] AFN05_F31_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }
        #endregion

        #region AFN_09H 请求终端配置及信息
        public static byte[] AFN09_F1_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN09_F9_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }
        #endregion

        #region AFN_0AH 查询参数
        public static byte[] AFN0A_F10_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0A_F66_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0A_F88_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }
        #endregion

        #region AFN_0CH 请求一类数据
        public static byte[] AFN0C_F2_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0C_F25_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0C_F33_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0C_F49_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0C_F129_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0C_F130_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0C_F131_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0C_F132_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0C_F145_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0C_F149_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0C_F188_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        #endregion

        #region AFN_0DH 请求二类数据
        public static byte[] AFN0D_F3_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F4_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F11_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F19_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F81_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F82_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F83_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F84_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F85_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F86_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F87_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }
        public static byte[] AFN0D_F88_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F89_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F90_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F91_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F92_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F93_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F94_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F95_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }
        public static byte[] AFN0D_F96_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }
        public static byte[] AFN0D_F97_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F98_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F99_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F100_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F101_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F102_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F103_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F104_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F105_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }
        public static byte[] AFN0D_F106_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F107_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F108_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F145_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F146_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F147_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F148_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F161_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F162_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }
        public static byte[] AFN0D_F163_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F164_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F165_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F166_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F167_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F1618_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F177_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F178_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F179_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }
        public static byte[] AFN0D_F180_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F181_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F182_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F183_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F184_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F190_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F193_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN0D_F195_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }
        #endregion

        #region AFN10H 数据转发
        public static byte[] AFN10_F4_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN10_F94_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN10_F97_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }
        public static byte[] AFN10_F101_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN10_F102_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN10_F103_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN10_F104_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN10_F105_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN10_F106_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN10_F107_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        public static byte[] AFN10_F249_Send(string address, int fn, int pn = 0)
        {
            var reqParameter = new ReqParameter2()
            {
                AFN = AFN.链路接口检测,
                FunCode = (int)CMasterStationFunCode.请求2级数据,
                A = address,
                Seq = new Seq()
                {
                    TpV = TpV.附加信息域中无时间标签,
                    FIRFIN = FIRFIN.单帧,
                    CON = CON.不需要对该帧进行确认,
                    PRSEQ = 0,
                },
                MSA = Build3761SendData.GetMSA(address),
                Pn = pn,
                Fn = fn
            };
            var bytes = Build3761SendData.BuildSendCommandBytes(reqParameter);
            return bytes;
        }

        #region SpecialAmmeter 特殊电表转发
        //TODO 特殊电表处理

        #endregion

        #endregion
    }
}