//Copyright 2012-2019 Keysight Technologies
|
//
|
//Licensed under the Apache License, Version 2.0 (the "License");
|
//you may not use this file except in compliance with the License.
|
//You may obtain a copy of the License at
|
//
|
//http://www.apache.org/licenses/LICENSE-2.0
|
//
|
//Unless required by applicable law or agreed to in writing, software
|
//distributed under the License is distributed on an "AS IS" BASIS,
|
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
//See the License for the specific language governing permissions and
|
//limitations under the License.
|
using System;
|
using System.Collections.Generic;
|
using System.ComponentModel;
|
using System.Linq;
|
using System.Xml.Serialization;
|
using OpenTap;
|
|
|
/// <summary>
|
/// This example contains a TAP plugin with simulated instrument and DUT. It shows
|
/// the basic interaction between Test Steps, DUTs, and Instruments. More detail
|
/// on the features found in the example can be found in the PluginDevelopment directory.
|
|
/// The project includes a SIMULATED:
|
/// - GeneratorInstrument (TAP Instrument).
|
/// - LowPassFilterDut (TAP DUT).
|
|
/// MeasurePeakAmplitudeTestStep (this file) is a TAP Test Step that:
|
/// 1. Programs the generator.
|
/// 2. Configures the low pass filter.
|
/// 3. Collects the results from the low pass filter.
|
/// 4. Publishes results to any configured result listeners.
|
/// </summary>
|
|
namespace OpenTap.Plugins.ExamplePlugin
|
{
|
// The display attribute defines the grouping, name and description of settings in the Add New Step window.
|
[Display(Groups: new[] { "Examples", "Example Plugin" }, Name: "Measure Peak Amplitude",
|
Description: "Checks the maximum value of a waveform after passing through a low pass filter.")]
|
// All Test Steps inherit from the TestStep base class.
|
public class MeasurePeakAmplitudeTestStep : TestStep
|
{
|
#region Settings
|
|
// Public properties with a getter and a setter will be shown in the TAP GUI.
|
// Non public properties are not shown in the GUI.
|
public double[] InputData { get; set; }
|
|
// The display attribute can be used to define how Step Settings (Properties) appear
|
// in the Step Settings panel.
|
[Display(Group: "Generator Settings", Name: "Generator", Order: 1.1)]
|
// Instruments are associated with a Test Step by adding a property of the desired instrument type.
|
// This can be an exact type, an interface, or base type such as ScpiInstrument, or Instrument.
|
public GeneratorInstrument MyGenerator { get; set; }
|
|
// DUT associations are added the same way as Instruments.
|
[Display(Group: "Filter (DUT) Settings", Name: "Filter", Order: 2.1)]
|
public LowPassFilterDut MyFilter { get; set; }
|
|
// Order is used to sort items within a group
|
[Display(Group: "Filter (DUT) Settings", Name: "Window Size", Order: 2.2,
|
Description: "Defines the size of the moving average window.")]
|
public int WindowSize { get; set; }
|
|
// Public properties are serialized upon loading/saving the TestPlan.
|
// The XmlIgnore attribute indicates that the data should not be serialized.
|
// This can be used when the user is required to specify a value, and there is no default value.
|
[XmlIgnore]
|
// Properties with private setters are not shown in the GUI. However, you may wish
|
// to have a "read only" view of a property. To achieve that, use the Browsable(true)
|
// attribute, and keep the setter private, as shown below.
|
[Browsable(true)]
|
[Display(Group: "Scope Settings", Name: "Output Data", Order: 3.1)]
|
public double[] ReadOnlyOutputData { get; private set; }
|
|
// Limit checking is usually done by creating Limit Settings, and then comparing the limits
|
// to the result values in the Run method (see below).
|
[Display(Group: "Limit Checking", Name: "Limit Check Enabled", Order: 4.1)]
|
public bool LimitCheckEnabled { get; set; }
|
|
[Display(Group: "Limit Checking", Name: "Max Amplitude", Order: 4.2,
|
Description: "The maximum amplitude allowed. If exceeded, the test will be marked as failed.")]
|
|
// The EnabledIf attribute allows for disabling/hiding elements based on the value of other items.
|
// Here the MaxAmplitude editor is disable if the LimitCheckEnabled property is true.
|
// You can find more examples in the Plugin Development\TestSteps\Attributes section.
|
[EnabledIf("LimitCheckEnabled", true, HideIfDisabled = true)]
|
public double MaxAmplitude { get; set; }
|
|
#endregion
|
|
public MeasurePeakAmplitudeTestStep()
|
{
|
// Default values for settings should be defined in the constructor.
|
LimitCheckEnabled = true;
|
MaxAmplitude = 50;
|
InputData = new double[] {0, 0, 0, 0, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0};
|
WindowSize = 3;
|
|
// Validation Rules can be defined in the constructor to restrict the user inputs.
|
Rules.Add(() => WindowSize > 0, "Window size must be greater than zero", "WindowSize");
|
Rules.Add(SizesAreAppropriate, "Input Data must be larger than window size", "WindowSize", "InputData");
|
}
|
|
//public override void PrePlanRun()
|
//{
|
// // This method is called on all TestSteps at the START of TestPlan execution.
|
// // If no setup code is needed, this method can be removed.
|
// base.PrePlanRun();
|
//}
|
|
public override void Run()
|
{
|
// The Run method is where the main execution logic of a TestStep exists.
|
// This is a required method.
|
try
|
{
|
// Setup instrument.
|
MyGenerator.SetInputData(InputData);
|
|
// Setup DUT.
|
MyFilter.WindowSize = WindowSize;
|
|
// Execute logic for DUT and handle data from DUT.
|
ReadOnlyOutputData = MyFilter.CalcMovingAverage(InputData);
|
|
// Check to see if limit checking is enabled. If so, Upgrade the verdict.
|
if (LimitCheckEnabled)
|
{
|
// The Verdict is used by TAP to convey the general execution result of a Test Step.
|
UpgradeVerdict(ReadOnlyOutputData.Max() >= MaxAmplitude ? Verdict.Fail : Verdict.Pass);
|
}
|
else
|
{
|
// All Test Steps have a standard Log object (inherited from the base class)
|
// that can be used to write messages to the run log and the session log.
|
Log.Debug("Limit checking was not enabled. This is why the verdict is inconclusive.");
|
UpgradeVerdict(Verdict.Inconclusive);
|
}
|
|
// Different log message types can be used based on what is being written.
|
Log.Info("The DUT comment is {0}", MyFilter.Comment);
|
|
// All Test Steps also contain a Results object. Results are store by calling Publish or PublishTable.
|
Results.PublishTable("Inputs Versus Moving Average", new List<string>() {"Input Values", "Output Values"},
|
InputData, ReadOnlyOutputData);
|
}
|
catch (Exception ex)
|
{
|
Log.Error(ex.Message);
|
|
// The verdict can be set more than once in a Test Step.
|
// UpgradeVerdict sets the current verdict to the more serious verdict.
|
// If the new Verdict is not more severe, the original setting will be kept.
|
UpgradeVerdict(Verdict.Error);
|
}
|
}
|
|
//public override void PostPlanRun()
|
//{
|
// // This method is called on all TestSteps at the END of TestPlan execution.
|
// // If no shutdown code is needed, this method can be removed.
|
// base.PostPlanRun();
|
//}
|
|
// Additional methods can be added to Test Step classes.
|
private bool SizesAreAppropriate()
|
{
|
return InputData.Length > WindowSize;
|
}
|
}
|
}
|
