JG_TpsLabStudio_LTS/tps/TpsLabStudio/models/PhaseNoise.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Tps_LQ_Transmitter.com;

namespace Tps_LQ_Transmitter.models
{
    class PhaseNoise: BaseModel
    {
        public PhaseNoise()
        {
            TemplateName = "相位噪声测试";
        }
        /// <summary>
        /// 相位噪声测试
        /// </summary>
        public override bool Run(TestNode parameters)
        {
            double y_value, x_value;
            
            //获取仪器
            var SA = this.tps.GetDevice("频谱仪");
           
            TransmitterSerialPort SerialClient = new TransmitterSerialPort();
            DataType PhaseNoisePrint = new DataType();//相位噪声
            OutData Data = new OutData();

            if (SA == null)
            {
                ShowMessage(MsgType.Error, string.Format("仪器不齐全，{0}/{1}无法运行", parameters.Channel, parameters.Name));
                return false;
            }
            ConfigParameter PowerPara = new ConfigParameter();
            PowerPara.ComPort = parameters.Parameters.GetParameter<string>("串口");
            PowerPara.OutLoss = parameters.Parameters.GetParameter<double>("输出损耗");
            PowerPara.StartFrequency = parameters.Parameters.GetParameter<double>("起始频率");
            PowerPara.StepFrequency = parameters.Parameters.GetParameter<double>("频率步进");
            PowerPara.FrequencyNumber = parameters.Parameters.GetParameter<int>("频点数量");
            PowerPara.StopFrequency = parameters.Parameters.GetParameter<double>("终止频率");
            PowerPara.PNosieOffsetFreq = parameters.Parameters.GetParameterToArray<double>("相位噪声偏置频率");
            PowerPara.SPAN = parameters.Parameters.GetParameter<string>("扫描带宽（SPAN）");
            PowerPara.REF = parameters.Parameters.GetParameter<string>("参考电平（REF）");
            PowerPara.RBW = parameters.Parameters.GetParameter<string>("分辨率带宽（RBW）");
            PowerPara.VBW = parameters.Parameters.GetParameter<string>("视频带宽（VBW）");
            PowerPara.ControlDelay = parameters.Parameters.GetParameter<int>("控制延时");
            PowerPara.PhaseNoiseUpper = parameters.Parameters.GetParameter<double >("相位噪声上限");
            if ((PowerPara.StartFrequency == 0) || ((PowerPara.StepFrequency == 0) && (PowerPara.FrequencyNumber == 0)) || (PowerPara.StopFrequency == 0)
                || (PowerPara.SPAN == null) || (PowerPara.REF == null) || (PowerPara.RBW == null) || (PowerPara.VBW == null) || (PowerPara.PhaseNoiseUpper==0))
            {
                ShowMessage(MsgType.Error, string.Format("配置文件中频率参数为空，{0}/{1}无法运行", parameters.Channel, parameters.Name));
                return false;
            }
            if (PowerPara.ControlDelay == 0)
            {
                PowerPara.ControlDelay = 10;
            }
            SA.Write("仪器复位"); SA.Query("OPC");
            SA.Write("REF", PowerPara.REF); SA.Query("OPC");
            SA.Write("MARK打开", "1"); SA.Query("OPC");



            //if (SA.Query("IDN").Contains("N9030"))
            //{
            //    SA.Write("MARK打开", "2"); SA.Query("OPC");
            //    SA.Write("DELT打开", "2"); SA.Query("OPC");

            //}
            

            
            if ((PowerPara.FrequencyNumber != 0) && (PowerPara.FrequencyNumber != 1) && (PowerPara.StepFrequency == 0))
            {
                PowerPara.StepFrequency = ((int)(((PowerPara.StopFrequency - PowerPara.StartFrequency) / (PowerPara.FrequencyNumber - 1)) * 100)) / 100;
            }
            if (PowerPara.StepFrequency != 0)
            {
                PowerPara.FrequencyNumber = ((int)((PowerPara.StopFrequency - PowerPara.StartFrequency) / PowerPara.StepFrequency)) + 1;
            }

            double CenterFreq,Freq;
            Data.PhaseNoise = new double[PowerPara.FrequencyNumber, PowerPara.PNosieOffsetFreq.Length];
           
            for (int point = 0;; point++)
            {
               
                CenterFreq = PowerPara.StartFrequency + PowerPara.StepFrequency * point;
                if (CenterFreq > PowerPara.StopFrequency || (PowerPara.FrequencyNumber == 1 && point == 1))
                {
                    break;
                }
                // 控制
               // SerialClient.DUT_Transmitter_Ctrol(PowerPara.ComPort, Convert.ToByte(point + 1));
                Thread.Sleep(PowerPara.ControlDelay);//单位ms

                if (SA.Query("IDN").Contains("N9030"))//N9030A型号频谱仪
                {
                    SA.Write("相位噪声测试模式");
                    SA.Query("OPC");
                    SA.Write("相位噪声载波频率设置", CenterFreq.ToString()); SA.Query("OPC");
                    //Psa.Write("相位噪声stopOffset", "200000"); Psa.QueryTimeout("OPC", 3000);
                    //Psa.Write("相位噪声startOffset", "20"); Psa.QueryTimeout("OPC", 3000);
                    SA.Write("相位噪声关闭平均");
                    SA.Query("OPC");
                    SA.Write("相位噪声打开MarkTable");
                    SA.Query("OPC");
                    SA.Write("相位噪声测试");
                    SA.Query("OPC");
                }
                else
                {
                    
                    SA.Write("SPAN", "0.1"); SA.Query("OPC");
                    SA.Write("RBWAUTO"); SA.Query("OPC");
                    SA.Write("VBWAUTO"); SA.Query("OPC");
                    SA.Write("CENTER", CenterFreq.ToString()); SA.Query("OPC");
                    SA.Write("SingleOrCont", "0"); SA.Query("OPC");
                    PsaPeakValue_Tracedata(SA, out y_value, out x_value, true);
                    SA.Write("CENTER",( x_value/1000000).ToString()); SA.Query("OPC");                  
                    
                    SA.Write("RBW", PowerPara.RBW); SA.Query("OPC");
                    SA.Write("VBW", PowerPara.VBW); SA.Query("OPC");

                }
      
                double[] PhaseNoiseOffsetVal = new double[PowerPara.PNosieOffsetFreq.Length];
                double PhaseNoiseMaxOffsetVal = 0;
                for ( int offset_num = 0; offset_num < PowerPara.PNosieOffsetFreq.Length; offset_num++)
                {
                    if (SA.Query("IDN").Contains("N9030"))//N9030A型号频谱仪
                    {
                        SA.Write("设置Mark频率Hz", "1", PowerPara.PNosieOffsetFreq[offset_num].ToString()); SA.Query("OPC");           
                        double temp = Math.Round(double.Parse(SA.Query("读Mark相位噪声值", "1")), 2); 
                    }
                    else
                    {
                       
                        SA.Write("SPAN",( PowerPara.PNosieOffsetFreq[offset_num]/1000*5).ToString()); SA.Query("OPC");
                        
                        SA.Write("SingleOrCont", "0"); SA.Query("OPC");
                        SA.Write("单次扫描"); SA.Query("OPC");
                        SA.Write("PEAK", "1"); SA.Query("OPC");
                        SA.Write("相位噪声测试模式", "1"); SA.Query("OPC");
                     
                     
                        SA.Write("设置DELT频率", "1", PowerPara.PNosieOffsetFreq[offset_num].ToString()); SA.Query("OPC");
                        Data.PhaseNoise[point, offset_num] = Math.Round(double.Parse(SA.Query("读相位噪声", "1")), 2);
                       

                    }                    
                    PhaseNoiseOffsetVal[offset_num] = Data.PhaseNoise[point, offset_num];
                }
                if (PowerPara.PNosieOffsetFreq.Length > 1)//计算相位噪声中的最大值
                {
                    PhaseNoiseMaxOffsetVal = PhaseNoiseOffsetVal.Max();
                }
                else
                {
                    PhaseNoiseMaxOffsetVal = PhaseNoiseOffsetVal[0];
                }
                PhaseNoisePrint.Test_name = parameters.Channel + "-相位噪声(dBc/Hz)-" + CenterFreq.ToString() + "MHz";
                PhaseNoisePrint.Upper = PowerPara.PhaseNoiseUpper;
                PhaseNoisePrint.TestVal = PhaseNoiseMaxOffsetVal;
                if (PhaseNoisePrint.TestVal <= PhaseNoisePrint.Upper)
                {
                    PhaseNoisePrint.Result = "是";
                }
                else
                {
                    PhaseNoisePrint.Result = "否";
                }
                tps.TestTableAddCell(PhaseNoisePrint.Test_name, "/", PhaseNoisePrint.Upper.ToString() ,PhaseNoisePrint.TestVal.ToString(), PhaseNoisePrint.Result);
                //if (parameters.Channel == "通道1")
                //{
                //    //tps.SetTestTableCellValue(point, 15, PhaseNoisePrint.Result, PhaseNoisePrint.TestVal);
                //}
                //else if (parameters.Channel == "通道2")
                //{
                //    //tps.SetTestTableCellValue(point + 15, 15, PhaseNoisePrint.Result, PhaseNoisePrint.TestVal);
                //}
            }
           
            SA.Write("关闭所有MARK"); SA.Query("OPC");
            return true;
        }

        public void PsaPeakValue_Tracedata(AppLibs.Devices.IVISA psa, out double Y_Maxvalue, out double X_Maxvalue, bool IsReturnX = false)
        {
            System.Threading.Thread.Sleep(20);
            X_Maxvalue = 0;
            Y_Maxvalue = 0;

            psa.Write("单次扫描");

            psa.Query("OPC");
            string tracedata = psa.Query("读曲线");
            string[] tracedatas = tracedata.Split(',');
            double[] tracedata_double = new double[tracedatas.Length];
            for (int i = 0; i < tracedatas.Length; i++)
            {
                tracedata_double[i] = double.Parse(tracedatas[i]);
            }
            Y_Maxvalue = tracedata_double.Max();
            if (IsReturnX)
            {
                int x = Array.IndexOf(tracedata_double, Y_Maxvalue);
                double startfreq = double.Parse(psa.Query("读起始频率"));
                double stopfreq = double.Parse(psa.Query("读截止频率"));
                double counts = double.Parse(psa.Query("测试点数读取"));
                X_Maxvalue = startfreq + (stopfreq - startfreq) * x / (counts - 1);
            }
            Y_Maxvalue = Math.Round(Y_Maxvalue, 3);
        }
        public class ConfigParameter
        {
            /// <summary>
            /// 串口
            /// </summary>
            public string ComPort { set; get; }
            /// <summary>
            /// 输出损耗
            /// </summary>
            public double OutLoss { set; get; }
            /// <summary>
            /// 产品测试的起始频率
            /// </summary>
            public double StartFrequency { set; get; }
            /// <summary>
            /// 产品测试的频率步进
            /// </summary>
            public double StepFrequency { set; get; }
            /// <summary>
            /// 产品测试的频点数量
            /// </summary>
            public int FrequencyNumber { set; get; }
            /// <summary>
            /// 产品的工作频带上限(终止频率)
            /// 功能：用于判断从起始频率按一定的步进测试是否超出产品工作频段上限
            /// </summary>
            public double StopFrequency { set; get; }
            /// <summary>
            /// 相位噪声偏置频率
            /// </summary>
            public double[] PNosieOffsetFreq { set; get; }
            /// <summary>
            ///设置频谱仪的SPAN
            /// </summary>
            public string SPAN { set; get; }
            /// <summary>
            /// 设置参考电平
            /// </summary>
            public string REF { set; get; }
            /// <summary>
            /// 设置RBW
            /// </summary>
            public string RBW { set; get; }
            /// <summary>
            /// 设置VBW
            /// </summary>
            public string VBW { set; get; }
            /// <summary>
            /// 控制延时
            /// </summary>
            public int ControlDelay { set; get; }
            /// <summary>
            /// 相位噪声上限
            /// </summary>
            public double  PhaseNoiseUpper{set;get;}
        }
        public class OutData
        {

            /// <summary>
            /// 相位噪声
            /// </summary>
            public double[,] PhaseNoise { set; get; }
           
        }
        //public class DataType
        //{

        //    /// <summary>
        //    /// 测试名称
        //    /// </summary>
        //    public string Test_name { set; get; }
        //    /// <summary>
        //    /// 指标下限
        //    /// </summary>
        //    public double Lower { set; get; }
        //    /// <summary>
        //    /// 指标上限
        //    /// </summary>
        //    public double Upper { set; get; }
        //    /// <summary>
        //    /// 测试值
        //    /// </summary>
        //    public double TestVal { set; get; }
        //    /// <summary>
        //    /// 判断结果
        //    /// </summary>
        //    public bool Result { set; get; }


        //}
    }
}