Exemple #1
0
        private List <double> GetMeterPowers(int channel, double time)
        {
            var powers = new List <double>();

            var sw = System.Diagnostics.Stopwatch.StartNew();

            while (!IsStop)
            {
                var power = MeasurementController.GetMeterPower(channel);
                if (power == double.MinValue)
                {
                    continue;
                }

                powers.Add(power);

                readingCallback?.Invoke(
                    "-",
                    powers.Max().ToString("F3"),
                    powers.Min().ToString("F3")
                    );

                if (sw.ElapsedMilliseconds > time * 1000D)
                {
                    sw.Stop();
                    break;
                }
            }
            readingCallback?.Invoke(
                "-",
                powers.Max().ToString("F3"),
                powers.Min().ToString("F3")
                );
            return(powers);
        }
Exemple #2
0
        private List <double> GetMeterPowers(int channel, double time)
        {
            var powers = new List <double>();

            var setting = TestPortSetting.Get(channel);
            var pm      = MeasurementController.GetMeterIsMaxMin(setting.DeviceID);

            if (pm != null)
            {
                System.Threading.Thread.Sleep(10);
                TryAction(() => {
                    return(pm.SetPowerMaxMin(0, setting.ChannelID, 1));
                }, 10);
                var sw = System.Diagnostics.Stopwatch.StartNew();
                while (!IsStop)
                {
                    if (sw.ElapsedMilliseconds > time * 1000D)
                    {
                        sw.Stop();
                        break;
                    }
                    System.Threading.Thread.Sleep(10);
                }

                TryAction(() => {
                    return(pm.SetPowerMaxMin(0, setting.ChannelID, 0));
                }, 10);

                var pw = double.MinValue;
                TryAction(() => {
                    return(pm.GetMaxPower(0, setting.ChannelID, out pw) && pw != double.MinValue);
                }, 10);

                if (pw == 0D)
                {
                    return(new List <double>());
                }

                if (pw != double.MinValue)
                {
                    powers.Add(pw);
                }

                TryAction(() => {
                    return(pm.GetMinPower(0, setting.ChannelID, out pw) && pw != double.MinValue);
                }, 10);

                if (pw != double.MinValue)
                {
                    powers.Add(pw);
                }
            }
            else
            {
                var sw = System.Diagnostics.Stopwatch.StartNew();
                while (!IsStop)
                {
                    var power = MeasurementController.GetMeterPower(channel);
                    if (power == double.MinValue)
                    {
                        continue;
                    }

                    powers.Add(power);
                    if (sw.ElapsedMilliseconds > time * 1000D)
                    {
                        sw.Stop();
                        break;
                    }
                }
            }


            return(powers);
        }
Exemple #3
0
        /// <summary>
        /// 测试项目
        /// </summary>
        /// <param name="item"></param>
        private void TestItem(ReferenceTestItem item)
        {
            var wl = item.Wavelenght;
            var ch = item.Channel;


            UpdateTestInfo(wl, ch);

            var value1 = double.MinValue;

            if (!MeasurementController.RunPointTest(
                    pdlReferces,
                    wl,
                    () => {
                return(!IsStop);
            },
                    () => {
                if (item.TestTypeID == TestTypes[1])     //IL
                {
                    if (pdlReferces)
                    {
                        TryAction(() => {
                            if (IsStop)
                            {
                                return(false);
                            }

                            var pws = GetMeterPowers(ch, MeasurementController.PDLTestTime);
                            if (pws.Count < 1)
                            {
                                return(false);
                            }
                            else
                            {
                                var max = Math.Round(pws.Max(), 3);
                                var min = Math.Round(pws.Min(), 3);
                                var avg = Math.Round(pws.Average(), 3);
                                var p = max;
                                if (Framework.MeasurementSystemSetting.SystemData.Setting.Profile.CalculateILType > 0)
                                {
                                    switch (Framework.MeasurementSystemSetting.SystemData.Setting.Profile.CalculateILType)
                                    {
                                    case 1:
                                        p = max;
                                        break;

                                    case 2:
                                        p = min;
                                        break;

                                    case 3:
                                        p = avg;
                                        break;
                                    }
                                }
                                value1 = p;
                            }
                            return(true);
                        }, 10);
                    }
                    else
                    {
                        value1 = MeasurementController.GetMeterPower(ch);
                    }
                }
                else     //RL
                {
                    value1 = MeasurementController.GetMeterMinPower(ch, Framework.MeasurementSystemSetting.SystemData.Setting.Profile.RetrunLosssTime);
                }
            }))
            {
                testResultCallback(item.ItemID, MeasurementController.ErrorString, item.LastValueString, 2);
                IsStop = true;
                return;
            }

            if (Framework.MeasurementSystemSetting.SystemData.Setting.Profile.CheckOpticalSource &&
                value1 < Framework.MeasurementSystemSetting.SystemData.Setting.Profile.OpticalSourceThreshold)
            {
                testResultCallback(item.ItemID, value1.ToString(), "", 2);
                ShowMessage(4, "光源太弱,请检查接线后再测试");
                return;
            }

            if (value1 == double.MinValue)
            {
                testResultCallback(item.ItemID, "读取失败", item.LastValueString, 2);
                ShowMessage(4, MeasurementController.ErrorString);
                return;
            }
            item.ReferenceData.Clear();
            item.ReferenceData.Add(new TPointTestItem()
            {
                WaveLength   = wl,
                MonitorPower = 0D,
                Power        = value1,
                IL           = 0D,
                PDL          = 0D,
                MaxPower     = 0D,
                MinPower     = 0D,
                AvgPower     = 0D,
                ExtendData   = new double[0]
            });

            var oldTemp = item.LastValueString;

            item.LastValueString = value1.ToString("F3");
            item.ValueString     = $"{value1}";

            testResultCallback(item.ItemID, value1.ToString("F3"), oldTemp, 1);
        }