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

namespace Tps_LQ_Transmitter.models
{
    class NormalTemperatureTest : BaseModel
    {
        public NormalTemperatureTest()
        {
            TemplateName = "常温检查测试";
        }
        public override bool Run(TestNode parameters)
        {
            DateTime currentTime1 = new DateTime();       
            Random random = new Random();
            
            //获取仪器
            var SA = this.tps.GetDevice("频谱仪"); 
            var DC = this.tps.GetDevice("程控电源");

            /*
            if (DC == null || SA == null)
            {
                ShowMessage(MsgType.Error, string.Format("仪器不齐全，{0}/{1}无法运行", parameters.Channel, parameters.Name));
                return false;
            }
            */
            ConfigParameter PowerPara = new ConfigParameter();
            PowerPara.IntervalTime = parameters.Parameters.GetParameter<int>("相对时间");//min
            PowerPara.TestTime = parameters.Parameters.GetParameter<int>("测试次数");//min
            int IntervalTime = (int)(PowerPara.IntervalTime * 60);//将min转换成s        
          
            int time=0;
            Stopwatch TimesCounter = new Stopwatch();
           
            while ( time < PowerPara.TestTime)
            {
                currentTime1 = DateTime.Now;
                TimesCounter.Restart();
                tps.SetTestTableCellValue(time, 3, true, currentTime1.Hour.ToString()+":"+ currentTime1.Minute.ToString());//测试时间
                tps.SetTestTableCellValue(time + PowerPara.TestTime, 3, true, currentTime1.Hour.ToString() + ":" + currentTime1.Minute.ToString());//测试时间
                MainTest(parameters,time);             
                
                while (TimesCounter.Elapsed.TotalSeconds <= IntervalTime && time!= PowerPara.TestTime-1)
                {
                    Thread.Sleep(100);
                    if (IsRuning == false)
                    {
                        return false;
                    }

                }
                TimesCounter.Stop();
                time = time + 1;
            }
   
            return true;
        }
        public bool MainTest(TestNode parameters,int time)
        {
           
            Random random = new Random();
            DataType VoltDataPrint = new DataType();
            DataType CurrentDataPrint = new DataType();
            DataType PowerPrint = new DataType();//功率(dBm)
            DataType FreqPrint = new DataType();//实测频率
            DataType FreqAccuracyPrint = new DataType();//频率稳定度
            DataType PowerSumPrint = new DataType();//两路功率总和(w)
            DataType PowerFlatnessPrint = new DataType();//两路功率不平度（dB）
            DataType ModulationIndexPrint = new DataType();
            DataType MaxFreqOffsetPrint = new DataType();
            DataType DBMaxFreqOffsetPrint = new DataType();
            DataType SpuriousSuppressionPrint = new DataType();
            DataType HarmonicSuppressionPrint = new DataType();

            //获取仪器
            var SA = this.tps.GetDevice("频谱仪");
            var DC = this.tps.GetDevice("程控电源");
            TransmitterSerialPort SerialClient = new TransmitterSerialPort();
            TestPara Data = new TestPara();

            /*
            if (DC == null || SA == null)
            {
                ShowMessage(MsgType.Error, string.Format("仪器不齐全，{0}/{1}无法运行", parameters.Channel, parameters.Name));
                return false;
            }
            */
            MatchModulaPara CfigModuParas = new MatchModulaPara();
            CfigModuParas = LoadModulationWorkBook();

            ConfigParameter PowerPara = new ConfigParameter();
            PowerPara.ComPort = parameters.Parameters.GetParameter<string>("串口");
            PowerPara.OutLoss = parameters.Parameters.GetParameter<double>("输出损耗");
            PowerPara.ChannelPara = parameters.Parameters.GetParameter<int>("通道数");
            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.SPAN = parameters.Parameters.GetParameter<string>("扫描带宽（SPAN）");
            PowerPara.REF = parameters.Parameters.GetParameter<string>("参考电平（REF）");
            PowerPara.SmallSignalREF = parameters.Parameters.GetParameter<string>("小信号参考电平（REF）");
            PowerPara.RBW = parameters.Parameters.GetParameter<string>("分辨率带宽（RBW）");
            PowerPara.VBW = parameters.Parameters.GetParameter<string>("视频带宽（VBW）");
            PowerPara.HarmonicTime = parameters.Parameters.GetParameterToArray<int>("谐波次数");
            PowerPara.ControlDelay = parameters.Parameters.GetParameter<int>("控制延时");
            PowerPara.VoltLower = parameters.Parameters.GetParameter<double>("电压下限");
            PowerPara.VoltUpper = parameters.Parameters.GetParameter<double>("电压上限");
            PowerPara.CurrentLower = parameters.Parameters.GetParameter<double>("电流下限");
            PowerPara.CurrentUpper = parameters.Parameters.GetParameter<double>("电流上限");
            PowerPara.PowerLower = parameters.Parameters.GetParameter<double>("功率下限");
            PowerPara.PowerUpper = parameters.Parameters.GetParameter<double>("功率上限");
            //PowerPara.FreqAccuracyUpper = parameters.Parameters.GetParameter<double>("频率稳定度上限");
           // PowerPara.PowerFlatnessUpper = parameters.Parameters.GetParameter<double>("功率不平度上限");
          //  PowerPara.ModulationIndexLower = parameters.Parameters.GetParameter<double>("调制系数下限");
          //  PowerPara.ModulationIndexUpper = parameters.Parameters.GetParameter<double>("调制系数上限");
            PowerPara.MaxFreqOffsetLower = parameters.Parameters.GetParameter<double>("最大频偏(KHz)下限");
            PowerPara.MaxFreqOffsetUpper = parameters.Parameters.GetParameter<double>("最大频偏(KHz)上限");
            PowerPara.SpuriousSuppressionLower = parameters.Parameters.GetParameter<double>("杂波抑制下限");
            PowerPara.HarmonicSuppressionLower = parameters.Parameters.GetParameter<double>("谐波抑制下限");


            if ((PowerPara.StartFrequency == 0) ||(PowerPara.ChannelPara == 0) ||((PowerPara.StepFrequency == 0) && (PowerPara.FrequencyNumber == 0)) || (PowerPara.StopFrequency == 0)
                || (PowerPara.SPAN == null) || (PowerPara.REF == null) || (PowerPara.RBW == null) || (PowerPara.VBW == null) || (PowerPara.PowerLower == 0)
                || (PowerPara.PowerUpper == 0) || (PowerPara.MaxFreqOffsetLower == 0) || (PowerPara.MaxFreqOffsetUpper == 0) || (PowerPara.SpuriousSuppressionLower == 0)
                ||(PowerPara.HarmonicSuppressionLower == 0))
            {
                ShowMessage(MsgType.Error, string.Format("配置文件中频率参数为空，{0}/{1}无法运行", parameters.Channel, parameters.Name));
                return false;
            }
            if (PowerPara.ControlDelay == 0)
            {
                PowerPara.ControlDelay = 10;
            }
            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;
            }
            int channel = 0;
            int point = 0;
            bool Result;
            double CenterFreq;
            double[] PowerDelt = new double[PowerPara.FrequencyNumber];
            Data.Power = new double[PowerPara.FrequencyNumber];
            Data.Freq = new double[PowerPara.FrequencyNumber];
            Data.FreqAccuracy = new double[PowerPara.FrequencyNumber];
            Data.ModulationIndex = new string[PowerPara.FrequencyNumber];
            Data.MaxFreqOffset = new string[PowerPara.FrequencyNumber];
            Data.DBMaxFreqOffset = new string[PowerPara.FrequencyNumber];


            for (channel = 0; channel < PowerPara.ChannelPara; channel++)
            {
                #region 输出功率、频率、电压、电流、调制频偏dB、调制频偏KHz测试
                //SA.Write("仪器复位"); SA.Query("OPC");
                //SA.Write("SPAN", PowerPara.SPAN); SA.Query("OPC");
                //SA.Write("RBW", PowerPara.RBW); SA.Query("OPC");
                //SA.Write("VBW", PowerPara.VBW); SA.Query("OPC");
                //SA.Write("REF", PowerPara.REF); SA.Query("OPC");

                //SA.Write("SingleOrCont", "0"); SA.Query("OPC");
                //SA.Write("MARK打开", "1"); SA.Query("OPC");
                //SA.Write("MARK打开", "2"); SA.Query("OPC");
                //SA.Write("DELT打开", "2"); SA.Query("OPC");
                for (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


                    #region 电压、电流测试
                    //Data.VoltVal[point] = DC.Query("读取电压");
                    //Data.CurrentVal[point] = DC.Query("读取电流");
                    VoltDataPrint.Lower = PowerPara.VoltLower;
                    VoltDataPrint.Upper = PowerPara.VoltUpper;
                    //VoltDataPrint.TestVal = double.Parse(Data.VoltVal[point]);
                    VoltDataPrint.TestVal = random.Next(2500, 3000) / 100.0;//随机数
                    Judge(VoltDataPrint.Lower, VoltDataPrint.Upper, VoltDataPrint.TestVal, out Result);
                    VoltDataPrint.Result = Result;

                    CurrentDataPrint.Lower = PowerPara.CurrentLower;
                    CurrentDataPrint.Upper = PowerPara.CurrentUpper;
                    //CurrentDataPrint.TestVal = double.Parse(Data.CurrentVal[point]);
                    CurrentDataPrint.TestVal = random.Next(90, 160) / 100.0;
                    Judge(CurrentDataPrint.Lower, CurrentDataPrint.Upper, CurrentDataPrint.TestVal, out Result);
                    CurrentDataPrint.Result = Result;
                    #endregion

                    #region 输出功率、频率测试
                    //SA.Write("CENTER", CenterFreq.ToString()); SA.Query("OPC");
                    //SA.Write("PEAK", "1"); SA.Query("OPC");
                    //SA.Write("NextPeak", "2"); SA.Query("OPC");
                    // PsaPeakValue_Tracedata(SA, out y_value, out x_value, true);
                    // Data.Power[point] = y_value + PowerPara.OutLoss;//功率
                    Data.Power[point] = random.Next(3000, 4000) / 100.0;//随机数
                  
                    PowerPrint.TestVal = Math.Round(Math.Pow(10, (Data.Power[point] / 10)) / 1000, 2);//功率W                  
                    Judge(PowerPara.PowerLower, PowerPara.PowerUpper, PowerPrint.TestVal, out Result);
                    PowerPrint.Result = Result;




                    FreqPrint.Lower = 0 - ((PowerPara.FreqAccuracyUpper * CenterFreq) + CenterFreq);
                    FreqPrint.Upper = (PowerPara.FreqAccuracyUpper * CenterFreq) + CenterFreq;
                    // FreqPrint.TestVal = Math.Round(x_value / 1000000, 3);//实测频率
                    FreqPrint.TestVal = random.Next(-600, 6000) / 100.0 + CenterFreq;//随机数
                    Judge(FreqPrint.Lower, FreqPrint.Upper, FreqPrint.TestVal, out Result);
                    FreqPrint.Result = Result;

                    #endregion

                    #region 调制测试
                    //PowerDelt[point] = double.Parse(SA.Query("读DELT功率", "2")); SA.Query("OPC");
                    PowerDelt[point] = random.Next(500, 1200) / 100.0;//随机数
                    double temp = 30;
                    string RelativeVal = "0";
                    foreach (KeyValuePair<string, ModulationMatchParameter> kvp in CfigModuParas.ModulaParameters)
                    {
                        if ((Math.Abs(PowerDelt[point] - double.Parse(kvp.Value.CfgRelative))) < temp)
                        {
                            temp = Math.Abs(PowerDelt[point] - double.Parse(kvp.Value.CfgRelative));
                            RelativeVal = kvp.Value.CfgRelative;
                        }
                    }

                    //Data.ModulationIndex[point] = CfigModuParas.GetModulaParameter(RelativeVal);//调制系数
                 
                    Data.MaxFreqOffset[point] = CfigModuParas.GetFreqOffsetParameter(RelativeVal);//最大频偏kHz
                    Data.DBMaxFreqOffset[point] = PowerDelt[point].ToString();//最大频偏dB

  
                    //ModulationIndexPrint.TestVal = double.Parse(Data.ModulationIndex[point]);
                    //Judge (PowerPara.ModulationIndexLower, PowerPara.ModulationIndexUpper, ModulationIndexPrint.TestVal, out Result);
                    //ModulationIndexPrint.Result = Result;

                    
                    MaxFreqOffsetPrint.TestVal = double.Parse(Data.MaxFreqOffset[point]);
                    DBMaxFreqOffsetPrint.TestVal = double.Parse(Data.DBMaxFreqOffset[point]);

                    Judge(PowerPara.MaxFreqOffsetLower, PowerPara.MaxFreqOffsetUpper, MaxFreqOffsetPrint.TestVal, out Result);
                    MaxFreqOffsetPrint.Result = Result;
                    DBMaxFreqOffsetPrint.Result = Result;

                    #endregion
                    if (channel == 0)
                    {
                        //  tps.SetTestTableCellValue(point, 2, SpuriousSuppressionPrint.Result, SpuriousSuppressionPrint.TestVal);//相对时间(min)
                        //  tps.SetTestTableCellValue(point, 3, SpuriousSuppressionPrint.Result, SpuriousSuppressionPrint.TestVal);//绝对时间
                        tps.SetTestTableCellValue(point + time, 4, VoltDataPrint.Result, VoltDataPrint.TestVal);//供电电压(V)
                        tps.SetTestTableCellValue(point + time, 5, CurrentDataPrint.Result, CurrentDataPrint.TestVal);//消耗电流(A)
                        tps.SetTestTableCellValue(point + time, 6, FreqPrint.Result, FreqPrint.TestVal);//输出频率(kHz)
                        tps.SetTestTableCellValue(point + time, 7, DBMaxFreqOffsetPrint.Result, DBMaxFreqOffsetPrint.TestVal);//调制频偏(dB)
                        tps.SetTestTableCellValue(point + time, 8, MaxFreqOffsetPrint.Result, MaxFreqOffsetPrint.TestVal);//调制频偏(kHz)
                        tps.SetTestTableCellValue(point + time, 9, PowerPrint.Result, PowerPrint.TestVal);//输出功率(W)

                    }
                    else if (channel == 1)
                    {
                        // tps.SetTestTableCellValue(point + 5, 2, SpuriousSuppressionPrint.Result, SpuriousSuppressionPrint.TestVal);//相对时间(min)
                        // tps.SetTestTableCellValue(point + 5, 3, SpuriousSuppressionPrint.Result, SpuriousSuppressionPrint.TestVal);//绝对时间
                        tps.SetTestTableCellValue(point + time + 5, 4, VoltDataPrint.Result, VoltDataPrint.TestVal);//供电电压(V)
                        tps.SetTestTableCellValue(point + time + 5, 5, CurrentDataPrint.Result, CurrentDataPrint.TestVal);//消耗电流(A)
                        tps.SetTestTableCellValue(point + time + 5, 6, FreqPrint.Result, FreqPrint.TestVal);//输出频率(kHz)
                        tps.SetTestTableCellValue(point + time + 5, 7, DBMaxFreqOffsetPrint.Result, DBMaxFreqOffsetPrint.TestVal);//调制频偏(dB)
                        tps.SetTestTableCellValue(point + time + 5, 8, MaxFreqOffsetPrint.Result, MaxFreqOffsetPrint.TestVal);//调制频偏(kHz)
                        tps.SetTestTableCellValue(point + time + 5, 9, PowerPrint.Result, PowerPrint.TestVal);//输出功率(W)

                    }
                }

                #endregion
                #region 杂波抑制
                //SA.Write("仪器复位"); SA.Query("OPC");
                //SA.Write("SPAN", PowerPara.SPAN); SA.Query("OPC");
                //SA.Write("REF", PowerPara.SmallSignalREF); SA.Query("OPC");
                //SA.Write("RBW", PowerPara.RBW); SA.Query("OPC");
                //SA.Write("VBW", PowerPara.VBW); SA.Query("OPC");
                //SA.Write("SingleOrCont", "0"); SA.Query("OPC");
                for (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               

                    //SA.Write("CENTER", CenterFreq.ToString()); SA.Query("OPC");
                    //PsaPeakValue_Tracedata(SA, out y_value, out x_value, false);
                    //Power = y_value;
                    ////测主频左侧杂散
                    //SA.Write("START", PowerPara.LeftStart.ToString()); SA.Query("OPC");
                    //SA.Write("STOP", (CenterFreq - PowerPara.LeftOffset).ToString()); SA.Query("OPC");
                    //PsaPeakValue_Tracedata(SA, out y_value, out x_value, false);
                    //PowerLeft = Power - y_value;
                    ////测主频右侧杂散
                    //SA.Write("START", (CenterFreq + PowerPara.RightOffset).ToString()); SA.Query("OPC");
                    //SA.Write("STOP", PowerPara.RightStop.ToString()); SA.Query("OPC");
                    //PsaPeakValue_Tracedata(SA, out y_value, out x_value, false);
                    //PowerRigth = Power - y_value;
                    SpuriousSuppressionPrint.Lower = PowerPara.SpuriousSuppressionLower;
                    //SpuriousSuppressionPrint.TestVal = Math.Round(Math.Min(PowerLeft, PowerRigth), 2);
                    SpuriousSuppressionPrint.TestVal = random.Next(4000, 12000) / 100.0;//随机数
                    Judge(SpuriousSuppressionPrint.Lower, 201, SpuriousSuppressionPrint.TestVal, out Result);
                    SpuriousSuppressionPrint.Result = Result;
                    if (channel == 0)
                    {
                        tps.SetTestTableCellValue(point + time, 10, SpuriousSuppressionPrint.Result, SpuriousSuppressionPrint.TestVal);//杂波抑制(dBc)
                      
                    }
                    else if (channel == 1)
                    {
                        tps.SetTestTableCellValue(point + time + 5, 10, SpuriousSuppressionPrint.Result, SpuriousSuppressionPrint.TestVal);//杂波抑制(dBc)
                     
                    }

                }
                #endregion
                #region 谐波抑制
                //SA.Write("仪器复位"); SA.Query("OPC");
                //SA.Write("SPAN", PowerPara.SPAN); SA.Query("OPC");
                //SA.Write("RBW", PowerPara.RBW); SA.Query("OPC");
                //SA.Write("VBW", PowerPara.VBW); SA.Query("OPC");
                //SA.Write("SingleOrCont", "0"); SA.Query("OPC");
                for (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


                    //SA.Write("CENTER", CenterFreq.ToString()); SA.Query("OPC");
                    //PsaPeakValue_Tracedata(SA, out y_value, out x_value, false);
                    //Power = y_value;

                    double[] HarmonicTimeVal = new double[PowerPara.HarmonicTime.Length];
                    double HarmonicMinTimeVal = 0;

                    //for ( harmonic_num = 0; harmonic_num < PowerPara.HarmonicTime.Length; harmonic_num++)
                    //{
                    //    SA.Write("CENTER", (CenterFreq * PowerPara.HarmonicTime[harmonic_num]).ToString()); SA.Query("OPC");//N次谐波
                    //    PsaPeakValue_Tracedata(SA, out y_value, out x_value, false);
                    //    Data.HarmonicSuppression[point,harmonic_num] = Math.Round( Power - y_value,2 );

                    //    HarmonicTimeVal[harmonic_num] = Data.HarmonicSuppression[point, harmonic_num];
                    //}

                    //if (PowerPara.HarmonicTime.Length > 1)//计算几次谐波中的最小值
                    //{
                    //    HarmonicMinTimeVal = HarmonicTimeVal.Min();
                    //}
                    //else
                    //{
                    //    HarmonicMinTimeVal = HarmonicTimeVal[0];
                    //}
                    HarmonicSuppressionPrint.Lower = PowerPara.HarmonicSuppressionLower;
                    HarmonicSuppressionPrint.TestVal = HarmonicMinTimeVal;
                    HarmonicSuppressionPrint.TestVal = random.Next(4000, 12000) / 100.0;//随机数
                    Judge(HarmonicSuppressionPrint.Lower, 201, HarmonicSuppressionPrint.TestVal, out Result);
                    HarmonicSuppressionPrint.Result = Result;
                    if (channel == 0)
                    {
                       
                        tps.SetTestTableCellValue(point + time, 11, HarmonicSuppressionPrint.Result, HarmonicSuppressionPrint.TestVal);//谐波抑制(dBc)
                    }
                    else if (channel == 1)
                    {
                        
                        tps.SetTestTableCellValue(point + time + 5, 11, HarmonicSuppressionPrint.Result, HarmonicSuppressionPrint.TestVal);//谐波抑制(dBc)
                    }
                }
                #endregion
                
            }
            return true;
        
        }
        /// <summary>
        /// 判断上下限
        /// </summary>
        /// <returns></returns>
        public void Judge(double Lower,double Upper,double TestValue,out bool JudgeResult)
        {
            if (Upper >= 200)
            {
                if (TestValue >= Lower)
                {
                    JudgeResult = true;
                }
                else
                {
                    JudgeResult = false;
                }
            }
            else if (Lower <= -200)
            {
                if (TestValue <= Upper)
                {
                    JudgeResult = true;
                }
                else
                {
                    JudgeResult = false;
                }
            }
            else
            {
                if (TestValue >= Lower && TestValue <= Upper)
                {
                    JudgeResult = true;
                }
                else
                {
                    JudgeResult = false;
                }
            }
           
        }

        public MatchModulaPara LoadModulationWorkBook()
        {
            MatchModulaPara pars = new MatchModulaPara();
            string FileName = Path.Combine(Bundle.bundle.BundleDir, "config\\ModulationMode.xlsx");
            if (!File.Exists(FileName))
            {
                ShowMessage(MsgType.Error, "找不到ModulationMode.xlsx");
                return null;
            }

            Spire.Xls.Workbook workbook = new Spire.Xls.Workbook();
            workbook.LoadFromFile(FileName);


            //获取第一个工作表sheet1
            Spire.Xls.Worksheet sheet = workbook.Worksheets[0];
            int num = 0;
            int blankRows = 0;

            while (num++ < 200)
            {
                //索引从1开始
                string col1 = sheet.Range[num, 1].Value2 != null ? sheet.Range[num, 1].Value2.ToString() : "";
                col1 = col1.Trim();
                if (string.IsNullOrEmpty(col1))
                {
                    blankRows++;
                    if (blankRows > 5)
                    {
                        //连续5个空行以上则退出
                        break;
                    }
                }
                else
                {
                    blankRows = 0;
                }
                if (col1.Equals("功率变化(dB)"))
                {
                    List<ModulationMatchParameter> ModulationTable = ReadParameters(sheet, num);

                    foreach (var item in ModulationTable)
                    {
                        if (pars.ModulaParameters.ContainsKey(item.CfgRelative))
                        {
                            ShowMessage(MsgType.Error, string.Format("调制对应表：{0} 存在同名参数：{1},无法重复添加参数", sheet.Name, item.CfgRelative));
                            continue;
                        }
                        pars.ModulaParameters.Add(item.CfgRelative, item);
                    }
                }
            }
            return pars;
        }



        List<ModulationMatchParameter> ReadParameters(Spire.Xls.Worksheet sheet, int rowIndex)
        {
            List<ModulationMatchParameter> ModulationTable = new List<ModulationMatchParameter>();
            string col1 = sheet.Range[rowIndex, 1].Value2 != null ? sheet.Range[rowIndex, 1].Value2.ToString() : "";
            string col2 = sheet.Range[rowIndex, 2].Value2 != null ? sheet.Range[rowIndex, 2].Value2.ToString() : "";
            string col3 = sheet.Range[rowIndex, 3].Value2 != null ? sheet.Range[rowIndex, 3].Value2.ToString() : "";

            if (!(col1 == "功率变化(dB)" && col2 == "调制指数(mf)" && col3 == "最大频偏(KHz)"))
            {
                ShowMessage(MsgType.Error, "'调制对应表'行首标题位置和格式不正确");
                return ModulationTable;
            }

            int num = rowIndex;
            //默认最多30行
            while (num++ < rowIndex + 100)
            {
                col1 = sheet.Range[num, 1].Value2 != null ? sheet.Range[num, 1].Value2.ToString() : "";
                col2 = sheet.Range[num, 2].Value2 != null ? sheet.Range[num, 2].Value2.ToString() : "";
                col3 = sheet.Range[num, 3].Value2 != null ? sheet.Range[num, 3].Value2.ToString() : "";
                if (string.IsNullOrEmpty(col1) || string.IsNullOrEmpty(col2) || string.IsNullOrEmpty(col3))
                {
                    break;
                }
                ModulationMatchParameter ObjModulation = new ModulationMatchParameter();
                ObjModulation.CfgRelative = col1;
                ObjModulation.CfgModulation = col2;
                ObjModulation.CfgFreqOffset = col3;

                ModulationTable.Add(ObjModulation);
            }
            return ModulationTable;
        }



        /// <summary>
        /// 一个调制指数的配置信息
        /// </summary>
        public class MatchModulaPara
        {
            public Dictionary<string, ModulationMatchParameter> ModulaParameters;
            public MatchModulaPara()
            {
                ModulaParameters = new Dictionary<string, ModulationMatchParameter>();
            }
            public string GetModulaParameter(string name)
            {
                if (string.IsNullOrEmpty(name))
                    return null;

                if (this.ModulaParameters.ContainsKey(name) == false)
                    return null;

                string val1 = this.ModulaParameters[name].CfgModulation.Trim();
                return val1;
            }
            public string GetFreqOffsetParameter(string name)
            {
                if (string.IsNullOrEmpty(name))
                    return null;

                if (this.ModulaParameters.ContainsKey(name) == false)
                    return null;

                string val2 = this.ModulaParameters[name].CfgFreqOffset.Trim();
                return val2;
            }
        }

        /// <summary>
        /// 调制指数3个对应项
        /// </summary>
        public class ModulationMatchParameter
        {

            /// <summary>
            /// 功率变化(dB)
            /// </summary>
            public string CfgRelative { get; set; }
            /// <summary>
            /// 调制指数(mf)
            /// </summary>
            public string CfgModulation { get; set; }
            /// <summary>
            /// 最大频偏(KHz)
            /// </summary>
            public string CfgFreqOffset { get; set; }


        }
        public class ConfigParameter
        {
            /// <summary>
            /// 串口
            /// </summary>
            public string ComPort { set; get; }
            /// <summary>
            /// 输出损耗
            /// </summary>
            public double OutLoss { set; get; }
            /// <summary>
            /// 通道数量
            /// </summary>
            public int ChannelPara { set; get; }
            /// <summary>
            /// 测试次数
            /// </summary>
            public int TestTime { set; get; }
            /// <summary>
            /// 相对时间
            /// </summary>
            public int IntervalTime { 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>
            ///设置频谱仪的SPAN
            /// </summary>
            public string SPAN { set; get; }
            /// <summary>
            /// 设置参考电平
            /// </summary>
            public string REF { set; get; }
            /// <summary>
            /// 设置小信号参考电平
            /// </summary>
            public string SmallSignalREF { set; get; }

            /// <summary>
            /// 设置RBW
            /// </summary>
            public string RBW { set; get; }
            /// <summary>
            /// 设置VBW
            /// </summary>
            public string VBW { set; get; }
            /// <summary>
            /// 谐波次数
            /// </summary>
            public int[] HarmonicTime { set; get; }
            /// <summary>
            /// 控制延时
            /// </summary>
            public int ControlDelay { set; get; }
            /// <summary>
            /// 功率下限
            /// </summary>
            public double PowerLower { set; get; }
            /// <summary>
            /// 功率上限
            /// </summary>
            public double PowerUpper { set; get; }
            /// <summary>
            /// 频率稳定度上限
            /// </summary>
            public double FreqAccuracyUpper { set; get; }
            /// <summary>
            /// 两路功率总和下限
            /// </summary>
            public double PowerSumLower { set; get; }
            /// <summary>
            /// 功率不平度上限
            /// </summary>
            public double PowerFlatnessUpper { set; get; }
            /// <summary>
            /// 调制系数下限
            /// </summary>
            public double ModulationIndexLower { get; set; }
            /// <summary>
            ///调制系数上限
            /// </summary>
            public double ModulationIndexUpper { get; set; }
            /// <summary>
            /// 最大频偏kHz下限
            /// </summary>
            public double MaxFreqOffsetLower { get; set; }
            /// <summary>
            ///最大频偏kHz调制系数上限
            /// </summary>
            public double MaxFreqOffsetUpper { get; set; }

            /// <summary>
            /// 杂波抑制下限
            /// </summary>
            public double SpuriousSuppressionLower { set; get; }
            // <summary>
            /// 谐波抑制下限
            /// </summary>
            public double HarmonicSuppressionLower { set; get; }

            /// <summary>
            /// 电压下限
            /// </summary>
            public double VoltLower { set; get; }
            /// <summary>
            /// 电压上限
            /// </summary>
            public double VoltUpper { set; get; }
            /// <summary>
            /// 电流下限
            /// </summary>
            public double CurrentLower { set; get; }
            /// <summary>
            /// 电流上限
            /// </summary>
            public double CurrentUpper { set; get; }

        }
        public class TestPara
        {
            /// <summary>
            /// 读电压值
            /// </summary>
            public string[] VoltVal { set; get; }
            /// <summary>
            /// 读电流值
            /// </summary>
            public string[] CurrentVal { set; get; }
            /// <summary>
            /// 输出功率(W)
            /// </summary>
            public double[] Power { set; get; }
            /// <summary>
            /// 频率稳定度
            /// </summary>
            public double[] FreqAccuracy { set; get; }
            /// <summary>
            /// 实测频点
            /// </summary>
            public double[] Freq { set; get; }
            /// <summary>
            /// 两路功率总和(W)
            /// </summary>
            public double[] PowerSum { set; get; }
            /// <summary>
            /// 两路功率不平度(dB)
            /// </summary>
            public double[] PowerFlatness { set; get; }
            /// <summary>
            ///调制系数
            /// </summary>
            public string[] ModulationIndex { set; get; }
            /// <summary>
            /// 最大频偏KHz
            /// </summary>
            public string[] MaxFreqOffset { set; get; }
            /// <summary>
            /// 最大频偏dB
            /// </summary>
            public string[] DBMaxFreqOffset { 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; }


        }
    }
   
}