Example #1
0
        private void GetPointRLTestData(IMeasurementTask testTask, string temp, TestSystemGroup systemGroup, WorkInfoSpecItem item, bool testAgain)
        {
            if (!item.TestSetting.IsDouble())
            {
                return;
            }
            var wl = item.TestSetting.CastTo(1550D);

            var type = "RL";

            if (!testAgain && testTask.ContainsTestData(type, temp, item.PortSetting, wl))
            {
                return;
            }
            currentChannel    = 1;
            currentWavelength = wl;
            testInfoCallback?.Invoke(currentWavelength, currentChannel, currentUnit);

            var pw = new List <double>();

            if (!MeasurementController.RunPointTest(
                    false,
                    currentWavelength,
                    () =>
            {
                return(!IsStop);
            },
                    () =>
            {
                var readTime = Framework.MeasurementSystemSetting.SystemData.Setting.Profile.RetrunLosssTime;
                pw = GetMeterPowers(1, readTime);
            }))
            {
                throw new Exception(MeasurementController.ErrorString);
            }
            if (pw.Count < 1)
            {
                throw new Exception("读取功率失败");
            }
            AddPointRLTestData(testTask, type, temp, item.PortSetting, currentWavelength, pw);
            return;
        }
Example #2
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);
        }
Example #3
0
        private void GetPointTestData(IMeasurementTask testTask, string temp, TestSystemGroup systemGroup, WorkInfoSpecItem item, bool testAgain)
        {
            if (!item.TestSetting.IsDouble())
            {
                return;
            }
            var wl = item.TestSetting.CastTo(1550D);

            if (item.PortSetting == 0)
            {
                return;
            }

            var type = "Point";

            if (!testAgain && testTask.ContainsTestData(type, temp, item.PortSetting, wl))
            {
                return;
            }

            currentChannel    = MeasurementController.GetSimultaneityPort(testTask.TestOrderID, item.PortSetting);
            currentWavelength = wl;
            testInfoCallback?.Invoke(currentWavelength, currentChannel, currentUnit);

            var pws = default(Dictionary <int, double>);

            if (!MeasurementController.RunPointTest(
                    false,
                    currentWavelength,
                    () =>
            {
                return(!IsStop);
            },
                    () =>
            {
                var setting = TestPortSetting.Get(currentChannel);
                pws = MeasurementController.GetMeterAllChannelPower(setting.DeviceID, setting.SwitchID);
            }))
            {
                throw new Exception(MeasurementController.ErrorString);
            }

            if (pws == null || pws.Count < 1)
            {
                throw new Exception($"读取功率失败,{MeasurementController.ErrorString}");
            }

            var items = MeasurementJob.SpecData.GetTestGroupWorkInfoSpecItems(systemGroup.TestGroupID);

            foreach (var testItem in items)
            {
                var pw = 0D;
                var c  = TestPortSetting.Get(testItem.PortSetting).ChannelID;
                if (!pws.TryGetValue(c, out pw))
                {
                    continue;
                }
                if (pw == double.MinValue)
                {
                    throw new Exception($"读取功率失败,{MeasurementController.ErrorString}");
                }
                AddPointTestData(testTask, type, temp, testItem.PortSetting, currentWavelength, pw);
            }
        }