public void WhenIGetTheAWGInstrumentCoupleSource(string awgNumber)
{
IAWG awg = AwgSetupSteps.GetAWG(awgNumber);
_awgInstrumentGroup.GetTheAwgInstrumentCoupleSource(awg);
}
/// <summary>
/// Test the event status enable register
/// </summary>
/// <param name="awg"></param>
/// <param name="expected_value"></param>
public void EventStatusEnableRegisterShouldBe(IAWG awg, string expected_value)
{
Assert.AreEqual(expected_value, awg.EventStatusEnableReg);
}
/// <summary>
/// Compare Status Operation NTransition Register against expected
/// </summary>
/// <param name="awg"></param>
/// <param name="expected_value"></param>
public void StatusOperationNTransitionRegisterShouldBe(IAWG awg, string expected_value)
{
Assert.AreEqual(expected_value, awg.StatusOperationNtransitionReg);
}
public void QueryResponseShouldBe(IAWG awg, string expectedValue)
{
Assert.AreEqual(expectedValue, awg.ReadResponse, "Expected response " + expectedValue + " did not match actual value " + awg.ReadResponse);
}
//glennj 06/06/2013
/// <summary>
/// Sets the value in the event status enable register to setValue variable
/// </summary>
/// <param name="awg">AWG object</param>
/// <param name="setValue">Desired value for event status enable register</param>
public void SetEventStatusEnableRegister(IAWG awg, string setValue)
{
awg.SetESE(setValue);
}
/// kaylak 11/14/2014
/// <summary>
/// Using OUTPut[n]:ATTenuator:A1 sets the step value setting for A1 attenuator of a channel in units of dB.
/// This is a blocking
/// </summary>
/// <param name="awg"></param>
/// <param name="outputIndex">Index of output</param>
/// <param name="filterStepValue">step increment value</param>
public void SetOutputFilterAttenuatorA1Step(IAWG awg, string outputIndex, string filterStepValue)
{
awg.SetOutputFilterAttenuatorA1Step(outputIndex, filterStepValue);
}
public void WriteCommandToAwg(IAWG awg, string command)
{
awg.VisaSessionWrite(command);
}
//glennj 1/7/2014
/// <summary>
/// Set the output "off" state for the AWG
/// </summary>
/// <param name="awg">Object</param>
/// <param name="enable">state</param>
public void SetOutputOffMode(IAWG awg, OutputOffStateMode enable)
{
string mode = (enable == OutputOffStateMode.On) ? SyntaxForOutputStateOn : SyntaxForOutputStateOff;
awg.SetOutputOff(mode);
}
//glennj 1/7/2014
/// <summary>
/// Force the AWG to update it's output "off" state.
/// </summary>
/// <param name="awg"></param>
public void GetOutputOffMode(IAWG awg)
{
awg.GetOutputOff();
}
/// kaylak 11/14/2014
/// <summary>
/// Using OUTPut[n]:FILTer:BPASs:RANGe? gets the band pass filter range
/// </summary>
/// <param name="awg"></param>
/// <param name="outputIndex">Index of output</param>
/// <returns>Type of Filter Path</returns>
public void GetOutputFilterBandPassRange(IAWG awg, string outputIndex)
{
awg.GetOutputFilterBandPassRange(outputIndex);
}
//jmanning 09/22/2014
/// <summary>
/// Using OUTPut[n]:MODE? gets the signal path [DIRect|AC]
/// </summary>
/// <param name="awg">Object</param>
/// <param name="outputIndex">Index of output</param>
/// <returns> Signal Path Type of Filter [DIRect|AC]</returns>
public void GetOutputMode(IAWG awg, string outputIndex)
{
awg.GetOutputMode(outputIndex);
}
public void SetOutputFilterBandPassRangeR10to14GHz(IAWG awg, string outputIndex, OutputFilterBandPassRange filterRange)
{
string expectedSyntax = "R10to14GHz";
awg.SetOutputFilterBandPassRangeR10to14GHz(outputIndex, expectedSyntax);
}
//jmanning 09/22/2014
/// <summary>
/// Using OUTPut[n]:FILTer? gets the filter type of the of the selected signal path
/// </summary>
/// <param name="awg"></param>
/// <param name="outputIndex">Index of output</param>
/// <returns> Type of Filter [NONE|BPASs|LPASs]</returns>
public void GetOutputFilter(IAWG awg, string outputIndex)
{
awg.GetOutputFilter(outputIndex);
}
public void ThenTheAWGInstrumentCoupleSourceShouldBeOn(string awgNumber)
{
IAWG awg = AwgSetupSteps.GetAWG(awgNumber);
_awgInstrumentGroup.AwgInstrumentCoupleSourceShouldBe(awg, AwgInstrumentGroup.InstrumentCoupleSource.On);
}
//glennj 1/8/2014
/// <summary>
/// Force the AWG to update it's copy of the wait state for a channel
/// </summary>
/// <param name="awg"></param>
/// <param name="logicalChannel"></param>
public void GetOutputTriggerAnalogState(IAWG awg, string logicalChannel)
{
awg.GetOutputWValueAnalogState(logicalChannel);
}
//glennj 1/7/2014
/// <summary>
/// Set the output state for a channel for an AWG
/// </summary>
/// <param name="awg"></param>
/// <param name="channel"></param>
/// <param name="stateChange"></param>
public void SetOutputState(IAWG awg, string channel, OutputStateMode stateChange)
{
string newState = stateChange == OutputStateMode.On ? SyntaxForOutputStateOn : SyntaxForOutputStateOff;
awg.SetOutputState(channel, newState);
}
//glennj 1/8/2014
/// <summary>
/// Force the AWG to update it's copy for the marker wait state for a channel
/// </summary>
/// <param name="awg"></param>
/// <param name="channel"></param>
/// <param name="marker"></param>
public void GetOutputWaitForTriggerMarkerState(IAWG awg, string channel, string marker)
{
awg.GetOutputTriggerMarkerState(channel, marker);
}
//glennj 1/7/2014
/// <summary>
/// Force the AWG to update it's channel output state for an AWG
/// </summary>
/// <param name="awg"></param>
/// <param name="channel"></param>
public void GetOutputState(IAWG awg, string channel)
{
awg.GetOutputState(channel);
}
/// kaylak 11/14/2014
/// <summary>
/// Using OUTPut[n]:ATTenuator:A1? gets the step value setting for A1attenuator of a channel in units of dB.
/// This is a blocking
/// </summary>
/// <param name="awg"></param>
/// <param name="outputIndex">Index of output</param>
/// <returns>step increment value</returns>
public void GetOutputFilterAttenuatorA1Step(IAWG awg, string outputIndex)
{
awg.GetOutputFilterAttenuatorA1Step(outputIndex);
}
//glennj 1/8/2014
/// <summary>
/// Set the Stop Value for analog for a channel for an AWG
/// </summary>
/// <param name="awg">AWG object</param>
/// <param name="logicalChannel">logical channel e.g. 1</param>
/// <param name="state">OutputAnalogStopMode</param>
public void SetOutputStopAnalogState(IAWG awg, string logicalChannel, OutputAnalogStopMode state)
{
string value = (state == OutputAnalogStopMode.Off) ? SyntaxForReturnedOutputStopValueAnalogOff : SyntaxForReturnedOutputStopValueAnalogZero;
awg.SetOutputStopAnalogState(logicalChannel, value);
}
public void QueryTheAwg(IAWG awg, string command)
{
awg.VisaSessionQuery(command);
}
//glennj 1/8/2014
/// <summary>
/// Force the AWG to update it's copy of the Stop Value for a channel and awg
/// </summary>
/// <param name="awg">AWG object</param>
/// <param name="logicalChannel">logical channel e.g. 1</param>
public void GetOutputStopAnalogState(IAWG awg, string logicalChannel)
{
awg.GetOutputStopAnalogState(logicalChannel);
}
/// <summary>
/// The Gherkin language does not support dynamic ranges such as Channels.<para>
/// Depending on the AWG it could have 1, 2 or 4 channels. Our software</para><para>
/// now needs to do it's own verification for correct channel count.</para>
/// </summary>
/// <param name="awg"></param>
/// <param name="logicalChannel"></param>
/// <param name="logicalMarker"></param>
/// <param name="logicalClock"></param>
public void VerifyChannelMarkerClockParameters(IAWG awg, string logicalChannel, string logicalMarker = null,
string logicalClock = null)
{
if (awg.ModelNumber.StartsWith("7"))
{
if (logicalChannel != null)
{
int logCh = Convert.ToInt32(logicalChannel);
string errorString = "Channel " + logicalChannel + " doesn't exist for " + awg.FamilyType;
if (awg.FamilyType.EndsWith("1"))
{
if (logCh != 1)
{
Assert.Fail(errorString);
}
}
else
{
if ((logCh < 1) || (logCh > 2))
{
Assert.Fail(errorString);
}
}
}
if (logicalMarker != null)
{
int logMk = Convert.ToInt32(logicalMarker);
string errorString = "Marker " + logicalMarker + " doesn't exist for " + awg.FamilyType;
if ((logMk < 1) || (logMk > 2))
{
Assert.Fail(errorString);
}
}
if (logicalClock != null)
{
int logClk = Convert.ToInt32(logicalClock);
string errorString = "Clock " + logicalClock + " doesn't exist for " + awg.FamilyType;
if (logClk != 1)
{
Assert.Fail(errorString);
}
}
}
else
{
if (logicalChannel != null)
{
int logCh = Convert.ToInt32(logicalChannel);
string errorString = "Channel " + logicalChannel + " doesn't exist for " + awg.FamilyType;
if (awg.FamilyType.EndsWith("1"))
{
if (logCh != 1)
{
Assert.Fail(errorString);
}
}
else if (awg.FamilyType.EndsWith("2"))
{
if ((logCh < 1) || (logCh > 2))
{
Assert.Fail(errorString);
}
}
else
{
if ((logCh < 1) || (logCh > 4))
{
Assert.Fail(errorString);
}
}
}
if (logicalMarker != null)
{
int logMk = Convert.ToInt32(logicalMarker);
string errorString = "Marker " + logicalMarker + " doesn't exist for " + awg.FamilyType;
if ((logMk < 1) || (logMk > 4))
{
Assert.Fail(errorString);
}
}
if (logicalClock != null)
{
int logClk = Convert.ToInt32(logicalClock);
string errorString = "Clock " + logicalClock + " doesn't exist for " + awg.FamilyType;
if (logClk != 1)
{
Assert.Fail(errorString);
}
}
}
}
//glennj 1/8/2014
/// <summary>
/// Set the Output Stop state for a marker and for an AWG
/// </summary>
/// <param name="awg"></param>
/// <param name="channel"></param>
/// <param name="marker"></param>
/// <param name="condition"></param>
public void SetOutputStopMarkerState(IAWG awg, string channel, string marker, OutputMarkerStopMode condition)
{
var setCondition = (condition == OutputMarkerStopMode.Off) ? SyntaxForOutputStopValueMarkerOff : SyntaxForOutputStopValueMarkerLow;
awg.SetOutputStopMarkerState(channel, marker, setCondition);
}
/// <summary>
/// Forces the AWG to update the copy of event status enable register contents
/// </summary>
/// <param name="awg">AWG object</param>
/// <returns>Desired value for event status enable register</returns>
public void GetEventStatusEnableRegister(IAWG awg)
{
awg.GetESE();
}
//glennj 1/8/2014
/// <summary>
/// Have the AWG update it's copy of the Output Stop state for a marker and for an AWG
/// </summary>
/// <param name="awg"></param>
/// <param name="channel"></param>
/// <param name="marker"></param>
public void GetOutputStopMarkerState(IAWG awg, string channel, string marker)
{
awg.GetOutputStopMarkerState(channel, marker);
}
/// <summary>
/// Get the current Status Operation N Transistion Register and <para>
/// update awg's copy</para>
/// </summary>
/// <param name="awg"></param>
public void GetStatusOperationNTransitionRegister(IAWG awg)
{
awg.GetStatusOperationNTransitionRegister();
}
//glennj 1/8/2014
/// <summary>
/// Set the output wait (trigger) state for a channel for an AWG
/// </summary>
/// <param name="awg"></param>
/// <param name="logicalChannel"></param>
/// <param name="state"></param>
public void SetOutputTriggerAnalogState(IAWG awg, string logicalChannel, OutputAnalogWaitMode state)
{
var value = (state == OutputAnalogWaitMode.First) ? SyntaxForOutputWaitValueAnalogFirst : SyntaxForOutputWaitValueAnalogZero;
awg.SetOutputWaitForValueAnalogState(logicalChannel, value);
}
/// <summary>
/// Sets the value in the Status Operation PTransition register
/// </summary>
/// <param name="awg">AWG object</param>
/// <param name="setValue">The value to set</param>
public void SetStatusOperationPTransitionRegister(IAWG awg, string setValue)
{
awg.SetStatusOperationPTransitionRegister(setValue);
}
public void WhenISetTheAWGInstrumentCoupleSourceToOff(string awgNumber)
{
IAWG awg = AwgSetupSteps.GetAWG(awgNumber);
_awgInstrumentGroup.SetTheAwgInstrumentCoupleSource(awg, AwgInstrumentGroup.InstrumentCoupleSource.Off);
}
