using FxpConvert.Common;
using NIFPGA;
using System.Diagnostics.CodeAnalysis;
/*
*设备:sbRIO-9638  顶层VI:FPGA_Main.vi  bit文件生成时间:2024/9/29 21:49:30
*/
namespace TestName
{
    public class Test
    {
        [AllowNull]
        private static Test myFpga;
        [AllowNull]
        private NIFPGA.FPGA fpga;
        private Test(IFxpConvert convert)
        {
        }
        static Test()
        {

        }
        private FPGAProperty<bool> _Start;
        /// <summary> 
        ///Start
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> Start
        {
            get
            {
                if (_Start == null)
                {
                    _Start = (FPGAProperty<bool>)fpga.Properties["Start"];
                }
                return _Start;
            }
        }
        private FPGAProperty<uint> _LoopRate;
        /// <summary> 
        ///LoopRate
        /// </summary>
        [AllowNull]
        public FPGAProperty<uint> LoopRate
        {
            get
            {
                if (_LoopRate == null)
                {
                    _LoopRate = (FPGAProperty<uint>)fpga.Properties["LoopRate"];
                }
                return _LoopRate;
            }
        }
        private FPGAFXPProperty _MaxDisplacement;
        /// <summary> 
        ///最大位移(V)
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty MaxDisplacement
        {
            get
            {
                if (_MaxDisplacement == null)
                {
                    _MaxDisplacement = (FPGAFXPProperty)fpga.Properties["最大位移(V)"];
                }
                return _MaxDisplacement;
            }
        }
        private FPGAFXPProperty _MaxAcceleration;
        /// <summary> 
        ///最大加速度(V)
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty MaxAcceleration
        {
            get
            {
                if (_MaxAcceleration == null)
                {
                    _MaxAcceleration = (FPGAFXPProperty)fpga.Properties["最大加速度(V)"];
                }
                return _MaxAcceleration;
            }
        }
        private FPGAFXPProperty _MaxDriver;
        /// <summary> 
        ///最大驱动(V)
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty MaxDriver
        {
            get
            {
                if (_MaxDriver == null)
                {
                    _MaxDriver = (FPGAFXPProperty)fpga.Properties["最大驱动(V)"];
                }
                return _MaxDriver;
            }
        }
        private FPGAFXPProperty _DisplacementP;
        /// <summary> 
        ///位移P增益
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty DisplacementP
        {
            get
            {
                if (_DisplacementP == null)
                {
                    _DisplacementP = (FPGAFXPProperty)fpga.Properties["位移P增益"];
                }
                return _DisplacementP;
            }
        }
        private FPGAFXPProperty _DisplacementI;
        /// <summary> 
        ///位移I增益
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty DisplacementI
        {
            get
            {
                if (_DisplacementI == null)
                {
                    _DisplacementI = (FPGAFXPProperty)fpga.Properties["位移I增益"];
                }
                return _DisplacementI;
            }
        }
        private FPGAFXPProperty _WarnAcceleration;
        /// <summary> 
        ///警告加速度(V)
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty WarnAcceleration
        {
            get
            {
                if (_WarnAcceleration == null)
                {
                    _WarnAcceleration = (FPGAFXPProperty)fpga.Properties["警告加速度(V)"];
                }
                return _WarnAcceleration;
            }
        }
        private FPGAFXPProperty _WarnDisplacement;
        /// <summary> 
        ///警告位移(V)
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty WarnDisplacement
        {
            get
            {
                if (_WarnDisplacement == null)
                {
                    _WarnDisplacement = (FPGAFXPProperty)fpga.Properties["警告位移(V)"];
                }
                return _WarnDisplacement;
            }
        }
        private FPGAFXPProperty _DisplacementBias;
        /// <summary> 
        ///缸位移直偏
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty DisplacementBias
        {
            get
            {
                if (_DisplacementBias == null)
                {
                    _DisplacementBias = (FPGAFXPProperty)fpga.Properties["缸位移直偏"];
                }
                return _DisplacementBias;
            }
        }
        private FPGAProperty<bool> _SignalStop;
        /// <summary> 
        ///发生停止
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> SignalStop
        {
            get
            {
                if (_SignalStop == null)
                {
                    _SignalStop = (FPGAProperty<bool>)fpga.Properties["发生停止"];
                }
                return _SignalStop;
            }
        }
        private FPGAFXPProperty _GivenLocation;
        /// <summary> 
        ///台给定工作位
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty GivenLocation
        {
            get
            {
                if (_GivenLocation == null)
                {
                    _GivenLocation = (FPGAFXPProperty)fpga.Properties["台给定工作位"];
                }
                return _GivenLocation;
            }
        }
        private FPGAProperty<bool> _Rise;
        /// <summary> 
        ///升振动台
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> Rise
        {
            get
            {
                if (_Rise == null)
                {
                    _Rise = (FPGAProperty<bool>)fpga.Properties["升振动台"];
                }
                return _Rise;
            }
        }
        private FPGAProperty<bool> _Rised;
        /// <summary> 
        ///升台完成
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> Rised
        {
            get
            {
                if (_Rised == null)
                {
                    _Rised = (FPGAProperty<bool>)fpga.Properties["升台完成"];
                }
                return _Rised;
            }
        }
        private FPGAProperty<bool> _Falled;
        /// <summary> 
        ///降完成
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> Falled
        {
            get
            {
                if (_Falled == null)
                {
                    _Falled = (FPGAProperty<bool>)fpga.Properties["降完成"];
                }
                return _Falled;
            }
        }
        private FPGAFXPProperty _ZeroDifference;
        /// <summary> 
        ///零位差
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty ZeroDifference
        {
            get
            {
                if (_ZeroDifference == null)
                {
                    _ZeroDifference = (FPGAFXPProperty)fpga.Properties["零位差"];
                }
                return _ZeroDifference;
            }
        }
        private FPGAFXPProperty _LastZeroDifference;
        /// <summary> 
        ///台上一时刻零位
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty LastZeroDifference
        {
            get
            {
                if (_LastZeroDifference == null)
                {
                    _LastZeroDifference = (FPGAFXPProperty)fpga.Properties["台上一时刻零位"];
                }
                return _LastZeroDifference;
            }
        }
        private FPGAProperty<bool> _ChangeZero;
        /// <summary> 
        ///零位改
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> ChangeZero
        {
            get
            {
                if (_ChangeZero == null)
                {
                    _ChangeZero = (FPGAProperty<bool>)fpga.Properties["零位改"];
                }
                return _ChangeZero;
            }
        }
        private FPGAProperty<bool> _SignalStart;
        /// <summary> 
        ///发生开始
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> SignalStart
        {
            get
            {
                if (_SignalStart == null)
                {
                    _SignalStart = (FPGAProperty<bool>)fpga.Properties["发生开始"];
                }
                return _SignalStart;
            }
        }
        private FPGAProperty<bool> _Fall;
        /// <summary> 
        ///降振动台
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> Fall
        {
            get
            {
                if (_Fall == null)
                {
                    _Fall = (FPGAProperty<bool>)fpga.Properties["降振动台"];
                }
                return _Fall;
            }
        }
        private FPGAFXPProperty _Location;
        /// <summary> 
        ///台实时位置
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty Location
        {
            get
            {
                if (_Location == null)
                {
                    _Location = (FPGAFXPProperty)fpga.Properties["台实时位置"];
                }
                return _Location;
            }
        }
        private FPGAFXPProperty _MaxDisplacementIntegral;
        /// <summary> 
        ///位移积分最大电压
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty MaxDisplacementIntegral
        {
            get
            {
                if (_MaxDisplacementIntegral == null)
                {
                    _MaxDisplacementIntegral = (FPGAFXPProperty)fpga.Properties["位移积分最大电压"];
                }
                return _MaxDisplacementIntegral;
            }
        }
        private FPGAFXPProperty _FlutterAmpt;
        /// <summary> 
        ///颤振信号幅值
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty FlutterAmpt
        {
            get
            {
                if (_FlutterAmpt == null)
                {
                    _FlutterAmpt = (FPGAFXPProperty)fpga.Properties["颤振信号幅值"];
                }
                return _FlutterAmpt;
            }
        }
        private FPGAFXPProperty _FlutterFrequency;
        /// <summary> 
        ///颤震频率
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty FlutterFrequency
        {
            get
            {
                if (_FlutterFrequency == null)
                {
                    _FlutterFrequency = (FPGAFXPProperty)fpga.Properties["颤震频率"];
                }
                return _FlutterFrequency;
            }
        }
        private FPGAProperty<uint> _MaxRiseCount;
        /// <summary> 
        ///升台面最大计数
        /// </summary>
        [AllowNull]
        public FPGAProperty<uint> MaxRiseCount
        {
            get
            {
                if (_MaxRiseCount == null)
                {
                    _MaxRiseCount = (FPGAProperty<uint>)fpga.Properties["升台面最大计数"];
                }
                return _MaxRiseCount;
            }
        }
        private FPGAProperty<uint> _MaxZeroChangedCount;
        /// <summary> 
        ///零位改最大计数
        /// </summary>
        [AllowNull]
        public FPGAProperty<uint> MaxZeroChangedCount
        {
            get
            {
                if (_MaxZeroChangedCount == null)
                {
                    _MaxZeroChangedCount = (FPGAProperty<uint>)fpga.Properties["零位改最大计数"];
                }
                return _MaxZeroChangedCount;
            }
        }
        private FPGAProperty<uint> _MaxSignalCount;
        /// <summary> 
        ///信号发生最大计数
        /// </summary>
        [AllowNull]
        public FPGAProperty<uint> MaxSignalCount
        {
            get
            {
                if (_MaxSignalCount == null)
                {
                    _MaxSignalCount = (FPGAProperty<uint>)fpga.Properties["信号发生最大计数"];
                }
                return _MaxSignalCount;
            }
        }
        private FPGAProperty<uint> _MaxStopWindowCount;
        /// <summary> 
        ///停止窗最大计数
        /// </summary>
        [AllowNull]
        public FPGAProperty<uint> MaxStopWindowCount
        {
            get
            {
                if (_MaxStopWindowCount == null)
                {
                    _MaxStopWindowCount = (FPGAProperty<uint>)fpga.Properties["停止窗最大计数"];
                }
                return _MaxStopWindowCount;
            }
        }
        private FPGAProperty<uint> _MaxFallCount;
        /// <summary> 
        ///降振动台最大计数
        /// </summary>
        [AllowNull]
        public FPGAProperty<uint> MaxFallCount
        {
            get
            {
                if (_MaxFallCount == null)
                {
                    _MaxFallCount = (FPGAProperty<uint>)fpga.Properties["降振动台最大计数"];
                }
                return _MaxFallCount;
            }
        }
        private FPGAProperty<uint> _MaxEmergencyStopCount;
        /// <summary> 
        ///急停处理最大计数
        /// </summary>
        [AllowNull]
        public FPGAProperty<uint> MaxEmergencyStopCount
        {
            get
            {
                if (_MaxEmergencyStopCount == null)
                {
                    _MaxEmergencyStopCount = (FPGAProperty<uint>)fpga.Properties["急停处理最大计数"];
                }
                return _MaxEmergencyStopCount;
            }
        }
        private FPGAProperty<uint> _ZeroChangedIndex;
        /// <summary> 
        ///零位改计数
        /// </summary>
        [AllowNull]
        public FPGAProperty<uint> ZeroChangedIndex
        {
            get
            {
                if (_ZeroChangedIndex == null)
                {
                    _ZeroChangedIndex = (FPGAProperty<uint>)fpga.Properties["零位改计数"];
                }
                return _ZeroChangedIndex;
            }
        }
        private FPGAProperty<uint> _StopWindowIndex;
        /// <summary> 
        ///停止窗计数
        /// </summary>
        [AllowNull]
        public FPGAProperty<uint> StopWindowIndex
        {
            get
            {
                if (_StopWindowIndex == null)
                {
                    _StopWindowIndex = (FPGAProperty<uint>)fpga.Properties["停止窗计数"];
                }
                return _StopWindowIndex;
            }
        }
        private FPGAProperty<uint> _EmergencyStopIndex;
        /// <summary> 
        ///急停计数
        /// </summary>
        [AllowNull]
        public FPGAProperty<uint> EmergencyStopIndex
        {
            get
            {
                if (_EmergencyStopIndex == null)
                {
                    _EmergencyStopIndex = (FPGAProperty<uint>)fpga.Properties["急停计数"];
                }
                return _EmergencyStopIndex;
            }
        }
        private FPGAProperty<bool> _SignalFinish;
        /// <summary> 
        ///发生完成
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> SignalFinish
        {
            get
            {
                if (_SignalFinish == null)
                {
                    _SignalFinish = (FPGAProperty<bool>)fpga.Properties["发生完成"];
                }
                return _SignalFinish;
            }
        }
        private FPGAFXPProperty _IdentifyDisplacement;
        /// <summary> 
        ///识别的位移幅值
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty IdentifyDisplacement
        {
            get
            {
                if (_IdentifyDisplacement == null)
                {
                    _IdentifyDisplacement = (FPGAFXPProperty)fpga.Properties["识别的位移幅值"];
                }
                return _IdentifyDisplacement;
            }
        }
        private FPGAProperty<bool> _ServoValvePolarity;
        /// <summary> 
        ///伺服阀极性
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> ServoValvePolarity
        {
            get
            {
                if (_ServoValvePolarity == null)
                {
                    _ServoValvePolarity = (FPGAProperty<bool>)fpga.Properties["伺服阀极性"];
                }
                return _ServoValvePolarity;
            }
        }
        private FPGAFXPProperty _IdentifyAcceleration;
        /// <summary> 
        ///识别的加速度幅值
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty IdentifyAcceleration
        {
            get
            {
                if (_IdentifyAcceleration == null)
                {
                    _IdentifyAcceleration = (FPGAFXPProperty)fpga.Properties["识别的加速度幅值"];
                }
                return _IdentifyAcceleration;
            }
        }
        private FPGAFXPProperty _InitialLocation;
        /// <summary> 
        ///台初始位置
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty InitialLocation
        {
            get
            {
                if (_InitialLocation == null)
                {
                    _InitialLocation = (FPGAFXPProperty)fpga.Properties["台初始位置"];
                }
                return _InitialLocation;
            }
        }
        private FPGAProperty<bool> _Troubleshooting;
        /// <summary> 
        ///故障解除
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> Troubleshooting
        {
            get
            {
                if (_Troubleshooting == null)
                {
                    _Troubleshooting = (FPGAProperty<bool>)fpga.Properties["故障解除"];
                }
                return _Troubleshooting;
            }
        }
        private FPGAFXPProperty _MaxJitterDisplacement;
        /// <summary> 
        ///最大抖动位移
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty MaxJitterDisplacement
        {
            get
            {
                if (_MaxJitterDisplacement == null)
                {
                    _MaxJitterDisplacement = (FPGAFXPProperty)fpga.Properties["最大抖动位移"];
                }
                return _MaxJitterDisplacement;
            }
        }
        private FPGAFXPProperty _MaxJitterAcceleration;
        /// <summary> 
        ///最大抖动加速度
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty MaxJitterAcceleration
        {
            get
            {
                if (_MaxJitterAcceleration == null)
                {
                    _MaxJitterAcceleration = (FPGAFXPProperty)fpga.Properties["最大抖动加速度"];
                }
                return _MaxJitterAcceleration;
            }
        }
        private FPGAProperty<bool> _OilStopped;
        /// <summary> 
        ///油源急停
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> OilStopped
        {
            get
            {
                if (_OilStopped == null)
                {
                    _OilStopped = (FPGAProperty<bool>)fpga.Properties["油源急停"];
                }
                return _OilStopped;
            }
        }
        private FPGAFXPProperty _RiseInterval;
        /// <summary> 
        ///升台面计数间隔
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty RiseInterval
        {
            get
            {
                if (_RiseInterval == null)
                {
                    _RiseInterval = (FPGAFXPProperty)fpga.Properties["升台面计数间隔"];
                }
                return _RiseInterval;
            }
        }
        private FPGAFXPProperty _ZeroChangedInterval;
        /// <summary> 
        ///零位改计数间隔
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty ZeroChangedInterval
        {
            get
            {
                if (_ZeroChangedInterval == null)
                {
                    _ZeroChangedInterval = (FPGAFXPProperty)fpga.Properties["零位改计数间隔"];
                }
                return _ZeroChangedInterval;
            }
        }
        private FPGAFXPProperty _EmergencyStopInterval;
        /// <summary> 
        ///急停计数间隔
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty EmergencyStopInterval
        {
            get
            {
                if (_EmergencyStopInterval == null)
                {
                    _EmergencyStopInterval = (FPGAFXPProperty)fpga.Properties["急停计数间隔"];
                }
                return _EmergencyStopInterval;
            }
        }
        private FPGAFXPProperty _FallInterval;
        /// <summary> 
        ///降振动台计数间隔
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty FallInterval
        {
            get
            {
                if (_FallInterval == null)
                {
                    _FallInterval = (FPGAFXPProperty)fpga.Properties["降振动台计数间隔"];
                }
                return _FallInterval;
            }
        }
        private FPGAFXPProperty _StopWindowInterval;
        /// <summary> 
        ///停止窗计数间隔
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty StopWindowInterval
        {
            get
            {
                if (_StopWindowInterval == null)
                {
                    _StopWindowInterval = (FPGAFXPProperty)fpga.Properties["停止窗计数间隔"];
                }
                return _StopWindowInterval;
            }
        }
        private FPGAFXPProperty _SignalInterval;
        /// <summary> 
        ///信号发生计数间隔
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty SignalInterval
        {
            get
            {
                if (_SignalInterval == null)
                {
                    _SignalInterval = (FPGAFXPProperty)fpga.Properties["信号发生计数间隔"];
                }
                return _SignalInterval;
            }
        }
        private FPGAFXPProperty _SampleRate;
        /// <summary> 
        ///采样率
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty SampleRate
        {
            get
            {
                if (_SampleRate == null)
                {
                    _SampleRate = (FPGAFXPProperty)fpga.Properties["采样率"];
                }
                return _SampleRate;
            }
        }
        private FPGAFXPProperty _SampleInterval;
        /// <summary> 
        ///采样间隔
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty SampleInterval
        {
            get
            {
                if (_SampleInterval == null)
                {
                    _SampleInterval = (FPGAFXPProperty)fpga.Properties["采样间隔"];
                }
                return _SampleInterval;
            }
        }
        private FPGAProperty<ushort> _WarnCode;
        /// <summary> 
        ///警告代码
        /// </summary>
        [AllowNull]
        public FPGAProperty<ushort> WarnCode
        {
            get
            {
                if (_WarnCode == null)
                {
                    _WarnCode = (FPGAProperty<ushort>)fpga.Properties["警告代码"];
                }
                return _WarnCode;
            }
        }
        private FPGAProperty<ushort> _ErrorCode;
        /// <summary> 
        ///错误代码
        /// </summary>
        [AllowNull]
        public FPGAProperty<ushort> ErrorCode
        {
            get
            {
                if (_ErrorCode == null)
                {
                    _ErrorCode = (FPGAProperty<ushort>)fpga.Properties["错误代码"];
                }
                return _ErrorCode;
            }
        }
        private FPGAProperty<bool> _ErrorCloseVavle;
        /// <summary> 
        ///故障关阀
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> ErrorCloseVavle
        {
            get
            {
                if (_ErrorCloseVavle == null)
                {
                    _ErrorCloseVavle = (FPGAProperty<bool>)fpga.Properties["故障关阀"];
                }
                return _ErrorCloseVavle;
            }
        }
        private FPGAProperty<bool> _AccelerationPolarity;
        /// <summary> 
        ///加速度传感器极性
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> AccelerationPolarity
        {
            get
            {
                if (_AccelerationPolarity == null)
                {
                    _AccelerationPolarity = (FPGAProperty<bool>)fpga.Properties["加速度传感器极性"];
                }
                return _AccelerationPolarity;
            }
        }
        private FPGAProperty<bool> _DisplacementOpenLoop;
        /// <summary> 
        ///位移开环
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> DisplacementOpenLoop
        {
            get
            {
                if (_DisplacementOpenLoop == null)
                {
                    _DisplacementOpenLoop = (FPGAProperty<bool>)fpga.Properties["位移开环"];
                }
                return _DisplacementOpenLoop;
            }
        }
        private FPGAProperty<bool> _OutSignal;
        /// <summary> 
        ///外部信号
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> OutSignal
        {
            get
            {
                if (_OutSignal == null)
                {
                    _OutSignal = (FPGAProperty<bool>)fpga.Properties["外部信号"];
                }
                return _OutSignal;
            }
        }
        private FPGAFXPProperty _MaxOutInput;
        /// <summary> 
        ///最大外部输入(V)
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty MaxOutInput
        {
            get
            {
                if (_MaxOutInput == null)
                {
                    _MaxOutInput = (FPGAFXPProperty)fpga.Properties["最大外部输入(V)"];
                }
                return _MaxOutInput;
            }
        }
        private FPGAFXPProperty _WarnOutInput;
        /// <summary> 
        ///警告外部输入(V)
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty WarnOutInput
        {
            get
            {
                if (_WarnOutInput == null)
                {
                    _WarnOutInput = (FPGAFXPProperty)fpga.Properties["警告外部输入(V)"];
                }
                return _WarnOutInput;
            }
        }
        private FPGAArrayFXPProperty _ValveBias;
        /// <summary> 
        ///伺服驱动电压直偏
        /// </summary>
        [AllowNull]
        public FPGAArrayFXPProperty ValveBias
        {
            get
            {
                if (_ValveBias == null)
                {
                    _ValveBias = (FPGAArrayFXPProperty)fpga.Properties["伺服驱动电压直偏"];
                }
                return _ValveBias;
            }
        }
        private FPGAArrayFXPProperty _OpenLoopDisplacement;
        /// <summary> 
        ///位移开环驱动电压
        /// </summary>
        [AllowNull]
        public FPGAArrayFXPProperty OpenLoopDisplacement
        {
            get
            {
                if (_OpenLoopDisplacement == null)
                {
                    _OpenLoopDisplacement = (FPGAArrayFXPProperty)fpga.Properties["位移开环驱动电压"];
                }
                return _OpenLoopDisplacement;
            }
        }
        private FPGAFXPProperty _OutSignalGain;
        /// <summary> 
        ///外部输入增益
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty OutSignalGain
        {
            get
            {
                if (_OutSignalGain == null)
                {
                    _OutSignalGain = (FPGAFXPProperty)fpga.Properties["外部输入增益"];
                }
                return _OutSignalGain;
            }
        }
        private FPGAProperty<uint> _ActualLoopRate;
        /// <summary> 
        ///Actual Loop Rate (Ticks)
        /// </summary>
        [AllowNull]
        public FPGAProperty<uint> ActualLoopRate
        {
            get
            {
                if (_ActualLoopRate == null)
                {
                    _ActualLoopRate = (FPGAProperty<uint>)fpga.Properties["Actual Loop Rate (Ticks)"];
                }
                return _ActualLoopRate;
            }
        }
        private FPGAProperty<uint> _SweepCount;
        /// <summary> 
        ///扫频次数
        /// </summary>
        [AllowNull]
        public FPGAProperty<uint> SweepCount
        {
            get
            {
                if (_SweepCount == null)
                {
                    _SweepCount = (FPGAProperty<uint>)fpga.Properties["扫频次数"];
                }
                return _SweepCount;
            }
        }
        private FPGAProperty<bool> _SweepDown;
        /// <summary> 
        ///下扫/上扫
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> SweepDown
        {
            get
            {
                if (_SweepDown == null)
                {
                    _SweepDown = (FPGAProperty<bool>)fpga.Properties["下扫/上扫"];
                }
                return _SweepDown;
            }
        }
        private FPGAProperty<bool> _Linear;
        /// <summary> 
        ///线性/对数
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> Linear
        {
            get
            {
                if (_Linear == null)
                {
                    _Linear = (FPGAProperty<bool>)fpga.Properties["线性/对数"];
                }
                return _Linear;
            }
        }
        private FPGAProperty<uint> _SweepIndex;
        /// <summary> 
        ///已扫次数
        /// </summary>
        [AllowNull]
        public FPGAProperty<uint> SweepIndex
        {
            get
            {
                if (_SweepIndex == null)
                {
                    _SweepIndex = (FPGAProperty<uint>)fpga.Properties["已扫次数"];
                }
                return _SweepIndex;
            }
        }
        private FPGAFXPProperty _CurrentFrequency;
        /// <summary> 
        ///当前频率
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty CurrentFrequency
        {
            get
            {
                if (_CurrentFrequency == null)
                {
                    _CurrentFrequency = (FPGAFXPProperty)fpga.Properties["当前频率"];
                }
                return _CurrentFrequency;
            }
        }
        private FPGAProperty<bool> _RTStatus;
        /// <summary> 
        ///RT Status
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> RTStatus
        {
            get
            {
                if (_RTStatus == null)
                {
                    _RTStatus = (FPGAProperty<bool>)fpga.Properties["RT Status"];
                }
                return _RTStatus;
            }
        }
        private FPGAProperty<bool> _ValvePower;
        /// <summary> 
        ///阀上电
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> ValvePower
        {
            get
            {
                if (_ValvePower == null)
                {
                    _ValvePower = (FPGAProperty<bool>)fpga.Properties["阀上电"];
                }
                return _ValvePower;
            }
        }
        private FPGAProperty<bool> _ZeroChanged;
        /// <summary> 
        ///零位改完成
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> ZeroChanged
        {
            get
            {
                if (_ZeroChanged == null)
                {
                    _ZeroChanged = (FPGAProperty<bool>)fpga.Properties["零位改完成"];
                }
                return _ZeroChanged;
            }
        }
        private FPGAFXPProperty _MaxFrequency;
        /// <summary> 
        ///最大频率
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty MaxFrequency
        {
            get
            {
                if (_MaxFrequency == null)
                {
                    _MaxFrequency = (FPGAFXPProperty)fpga.Properties["最大频率"];
                }
                return _MaxFrequency;
            }
        }
        private FPGAFXPProperty _MinFrequency;
        /// <summary> 
        ///最小频率
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty MinFrequency
        {
            get
            {
                if (_MinFrequency == null)
                {
                    _MinFrequency = (FPGAFXPProperty)fpga.Properties["最小频率"];
                }
                return _MinFrequency;
            }
        }
        private FPGAProperty<uint> _RiseIndex;
        /// <summary> 
        ///升台面计数
        /// </summary>
        [AllowNull]
        public FPGAProperty<uint> RiseIndex
        {
            get
            {
                if (_RiseIndex == null)
                {
                    _RiseIndex = (FPGAProperty<uint>)fpga.Properties["升台面计数"];
                }
                return _RiseIndex;
            }
        }
        private FPGAProperty<uint> _FallIndex;
        /// <summary> 
        ///降台面计数
        /// </summary>
        [AllowNull]
        public FPGAProperty<uint> FallIndex
        {
            get
            {
                if (_FallIndex == null)
                {
                    _FallIndex = (FPGAProperty<uint>)fpga.Properties["降台面计数"];
                }
                return _FallIndex;
            }
        }
        private FPGAFXPProperty _SweepSpeed;
        /// <summary> 
        ///扫频速度
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty SweepSpeed
        {
            get
            {
                if (_SweepSpeed == null)
                {
                    _SweepSpeed = (FPGAFXPProperty)fpga.Properties["扫频速度"];
                }
                return _SweepSpeed;
            }
        }
        private FPGAProperty<bool> _SelfLoop;
        /// <summary> 
        ///自闭环
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> SelfLoop
        {
            get
            {
                if (_SelfLoop == null)
                {
                    _SelfLoop = (FPGAProperty<bool>)fpga.Properties["自闭环"];
                }
                return _SelfLoop;
            }
        }
        private FPGAProperty<bool> _debug;
        /// <summary> 
        ///debug
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> debug
        {
            get
            {
                if (_debug == null)
                {
                    _debug = (FPGAProperty<bool>)fpga.Properties["debug"];
                }
                return _debug;
            }
        }
        private FPGAProperty<bool> _SweepPhase;
        /// <summary> 
        ///扫频阶段
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> SweepPhase
        {
            get
            {
                if (_SweepPhase == null)
                {
                    _SweepPhase = (FPGAProperty<bool>)fpga.Properties["扫频阶段"];
                }
                return _SweepPhase;
            }
        }
        private FPGAFXPProperty _InitialDisplacement;
        /// <summary> 
        ///初始位移
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty InitialDisplacement
        {
            get
            {
                if (_InitialDisplacement == null)
                {
                    _InitialDisplacement = (FPGAFXPProperty)fpga.Properties["初始位移"];
                }
                return _InitialDisplacement;
            }
        }
        private FPGAFXPProperty _DriverVoltage;
        /// <summary> 
        ///驱动电压
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty DriverVoltage
        {
            get
            {
                if (_DriverVoltage == null)
                {
                    _DriverVoltage = (FPGAFXPProperty)fpga.Properties["驱动电压"];
                }
                return _DriverVoltage;
            }
        }
        private FPGAFXPProperty _TargetAcceleration;
        /// <summary> 
        ///调整目标加速度
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty TargetAcceleration
        {
            get
            {
                if (_TargetAcceleration == null)
                {
                    _TargetAcceleration = (FPGAFXPProperty)fpga.Properties["调整目标加速度"];
                }
                return _TargetAcceleration;
            }
        }
        private FPGAFXPProperty _AdjustDisplacement;
        /// <summary> 
        ///调整位移
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty AdjustDisplacement
        {
            get
            {
                if (_AdjustDisplacement == null)
                {
                    _AdjustDisplacement = (FPGAFXPProperty)fpga.Properties["调整位移"];
                }
                return _AdjustDisplacement;
            }
        }
        private FPGAFXPProperty _GivenDisplacement;
        /// <summary> 
        ///给定的位移幅值
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty GivenDisplacement
        {
            get
            {
                if (_GivenDisplacement == null)
                {
                    _GivenDisplacement = (FPGAFXPProperty)fpga.Properties["给定的位移幅值"];
                }
                return _GivenDisplacement;
            }
        }
        private FPGAFXPProperty _UpperStop;
        /// <summary> 
        ///上限停机电压
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty UpperStop
        {
            get
            {
                if (_UpperStop == null)
                {
                    _UpperStop = (FPGAFXPProperty)fpga.Properties["上限停机电压"];
                }
                return _UpperStop;
            }
        }
        private FPGAFXPProperty _LowerStop;
        /// <summary> 
        ///下限停机电压
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty LowerStop
        {
            get
            {
                if (_LowerStop == null)
                {
                    _LowerStop = (FPGAFXPProperty)fpga.Properties["下限停机电压"];
                }
                return _LowerStop;
            }
        }
        private FPGAFXPProperty _UpperWarn;
        /// <summary> 
        ///上限警告电压
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty UpperWarn
        {
            get
            {
                if (_UpperWarn == null)
                {
                    _UpperWarn = (FPGAFXPProperty)fpga.Properties["上限警告电压"];
                }
                return _UpperWarn;
            }
        }
        private FPGAFXPProperty _LowerWarn;
        /// <summary> 
        ///下限警告电压
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty LowerWarn
        {
            get
            {
                if (_LowerWarn == null)
                {
                    _LowerWarn = (FPGAFXPProperty)fpga.Properties["下限警告电压"];
                }
                return _LowerWarn;
            }
        }
        private FPGAProperty<bool> _FixedFrequency;
        /// <summary> 
        ///定频/扫频
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> FixedFrequency
        {
            get
            {
                if (_FixedFrequency == null)
                {
                    _FixedFrequency = (FPGAProperty<bool>)fpga.Properties["定频/扫频"];
                }
                return _FixedFrequency;
            }
        }
        private FPGAProperty<ulong> _MaxFixedFrequencyTime;
        /// <summary> 
        ///定频最大时间
        /// </summary>
        [AllowNull]
        public FPGAProperty<ulong> MaxFixedFrequencyTime
        {
            get
            {
                if (_MaxFixedFrequencyTime == null)
                {
                    _MaxFixedFrequencyTime = (FPGAProperty<ulong>)fpga.Properties["定频最大时间"];
                }
                return _MaxFixedFrequencyTime;
            }
        }
        private FPGAProperty<ulong> _FixedFrequencyTime;
        /// <summary> 
        ///已定频时间
        /// </summary>
        [AllowNull]
        public FPGAProperty<ulong> FixedFrequencyTime
        {
            get
            {
                if (_FixedFrequencyTime == null)
                {
                    _FixedFrequencyTime = (FPGAProperty<ulong>)fpga.Properties["已定频时间"];
                }
                return _FixedFrequencyTime;
            }
        }
        private FPGAProperty<uint> _MaxAdjustCount;
        /// <summary> 
        ///量级调整最大计数
        /// </summary>
        [AllowNull]
        public FPGAProperty<uint> MaxAdjustCount
        {
            get
            {
                if (_MaxAdjustCount == null)
                {
                    _MaxAdjustCount = (FPGAProperty<uint>)fpga.Properties["量级调整最大计数"];
                }
                return _MaxAdjustCount;
            }
        }
        private FPGAFXPProperty _AdjustInverval;
        /// <summary> 
        ///量级调整间隔
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty AdjustInverval
        {
            get
            {
                if (_AdjustInverval == null)
                {
                    _AdjustInverval = (FPGAFXPProperty)fpga.Properties["量级调整间隔"];
                }
                return _AdjustInverval;
            }
        }
        private FPGAProperty<uint> _AdjustIndex;
        /// <summary> 
        ///量级调整计数
        /// </summary>
        [AllowNull]
        public FPGAProperty<uint> AdjustIndex
        {
            get
            {
                if (_AdjustIndex == null)
                {
                    _AdjustIndex = (FPGAProperty<uint>)fpga.Properties["量级调整计数"];
                }
                return _AdjustIndex;
            }
        }
        private FPGAFXPProperty _AdjustTime;
        /// <summary> 
        ///量级调整时间
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty AdjustTime
        {
            get
            {
                if (_AdjustTime == null)
                {
                    _AdjustTime = (FPGAFXPProperty)fpga.Properties["量级调整时间"];
                }
                return _AdjustTime;
            }
        }
        private FPGAFXPProperty _SynthesisAmpt;
        /// <summary> 
        ///合成的幅值
        /// </summary>
        [AllowNull]
        public FPGAFXPProperty SynthesisAmpt
        {
            get
            {
                if (_SynthesisAmpt == null)
                {
                    _SynthesisAmpt = (FPGAFXPProperty)fpga.Properties["合成的幅值"];
                }
                return _SynthesisAmpt;
            }
        }
        private FPGAArrayFXPProperty _AccelerationData;
        /// <summary> 
        ///加速度数据
        /// </summary>
        [AllowNull]
        public FPGAArrayFXPProperty AccelerationData
        {
            get
            {
                if (_AccelerationData == null)
                {
                    _AccelerationData = (FPGAArrayFXPProperty)fpga.Properties["加速度数据"];
                }
                return _AccelerationData;
            }
        }
        private FPGAArrayFXPProperty _DisplacementData;
        /// <summary> 
        ///位移数据
        /// </summary>
        [AllowNull]
        public FPGAArrayFXPProperty DisplacementData
        {
            get
            {
                if (_DisplacementData == null)
                {
                    _DisplacementData = (FPGAArrayFXPProperty)fpga.Properties["位移数据"];
                }
                return _DisplacementData;
            }
        }
        private FPGAProperty<ulong> _StartCount;
        /// <summary> 
        ///开始点数
        /// </summary>
        [AllowNull]
        public FPGAProperty<ulong> StartCount
        {
            get
            {
                if (_StartCount == null)
                {
                    _StartCount = (FPGAProperty<ulong>)fpga.Properties["开始点数"];
                }
                return _StartCount;
            }
        }
        private FPGAProperty<bool> _CurrentSweepDirection;
        /// <summary> 
        ///当前扫频方向
        /// </summary>
        [AllowNull]
        public FPGAProperty<bool> CurrentSweepDirection
        {
            get
            {
                if (_CurrentSweepDirection == null)
                {
                    _CurrentSweepDirection = (FPGAProperty<bool>)fpga.Properties["当前扫频方向"];
                }
                return _CurrentSweepDirection;
            }
        }
        private FPGAProperty<uint> _ViControl;
        /// <summary> 
        ///ViControl
        /// </summary>
        [AllowNull]
        public FPGAProperty<uint> ViControl
        {
            get
            {
                if (_ViControl == null)
                {
                    _ViControl = (FPGAProperty<uint>)fpga.Properties["ViControl"];
                }
                return _ViControl;
            }
        }
        private FPGAProperty<uint> _DiagramReset;
        /// <summary> 
        ///DiagramReset
        /// </summary>
        [AllowNull]
        public FPGAProperty<uint> DiagramReset
        {
            get
            {
                if (_DiagramReset == null)
                {
                    _DiagramReset = (FPGAProperty<uint>)fpga.Properties["DiagramReset"];
                }
                return _DiagramReset;
            }
        }
        private FPGAArrayProperty<uint> _ViSignature;
        /// <summary> 
        ///ViSignature
        /// </summary>
        [AllowNull]
        public FPGAArrayProperty<uint> ViSignature
        {
            get
            {
                if (_ViSignature == null)
                {
                    _ViSignature = (FPGAArrayProperty<uint>)fpga.Properties["ViSignature"];
                }
                return _ViSignature;
            }
        }
        private FPGAProperty<uint> _InterruptEnable;
        /// <summary> 
        ///InterruptEnable
        /// </summary>
        [AllowNull]
        public FPGAProperty<uint> InterruptEnable
        {
            get
            {
                if (_InterruptEnable == null)
                {
                    _InterruptEnable = (FPGAProperty<uint>)fpga.Properties["InterruptEnable"];
                }
                return _InterruptEnable;
            }
        }
        private FPGAProperty<uint> _InterruptMask;
        /// <summary> 
        ///InterruptMask
        /// </summary>
        [AllowNull]
        public FPGAProperty<uint> InterruptMask
        {
            get
            {
                if (_InterruptMask == null)
                {
                    _InterruptMask = (FPGAProperty<uint>)fpga.Properties["InterruptMask"];
                }
                return _InterruptMask;
            }
        }
        private FPGAProperty<uint> _InterruptStatus;
        /// <summary> 
        ///InterruptStatus
        /// </summary>
        [AllowNull]
        public FPGAProperty<uint> InterruptStatus
        {
            get
            {
                if (_InterruptStatus == null)
                {
                    _InterruptStatus = (FPGAProperty<uint>)fpga.Properties["InterruptStatus"];
                }
                return _InterruptStatus;
            }
        }
        private WriteFXPFifo _Write;
        /// <summary> 
        ///Write
        /// </summary>
        [AllowNull]
        public WriteFXPFifo Write
        {
            get
            {
                if (_Write == null)
                {
                    _Write = (WriteFXPFifo)fpga.Fifos["Write"];
                }
                return _Write;
            }
        }
        public Irq Irq => fpga.Irq;
        public void Open(string bitfile, string resource, NiFpga_OpenAttribute attribute) => fpga.Open(bitfile, resource, attribute);
        public void Close() => fpga.Close();
        public void Run() => fpga.Run();
        public void Download() => fpga.Download();
        public void Abort() => fpga.Abort();
        public void Reset() => fpga.Reset();
        public static Test CreateFpga(IFxpConvert convert)
        {

            if (myFpga == null)
            {
                myFpga = new Test(convert);
            }
            return myFpga;
        }
        public static Test Instance
        {
            get
            {
                if (myFpga == null)
                {
                    throw new Exception($"must call first {CreateFpga}");
                }
                return myFpga;
            }
        }
    }
}
