# # This file is part of the PyMeasure package. # # Copyright (c) 2013-2024 PyMeasure Developers # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. # import pytest from pymeasure.test import expected_protocol from pymeasure.instruments.agilent.agilent33500 import Agilent33500 @pytest.mark.parametrize( "shape", ["SIN", "SQU", "TRI", "RAMP", "PULS", "PRBS", "NOIS", "ARB", "DC"] ) def test_shape(shape): """ Test Agilent 33500 shape function """ with expected_protocol( Agilent33500, [ ("SOUR1:FUNC?", shape), ("SOUR2:FUNC?", shape), ("FUNC?", shape), (f"SOUR1:FUNC {shape}", None), (f"SOUR2:FUNC {shape}", None), (f"FUNC {shape}", None), ], ) as inst: assert shape == inst.ch_1.shape assert shape == inst.ch_2.shape assert shape == inst.shape inst.ch_1.shape = shape inst.ch_2.shape = shape inst.shape = shape @pytest.mark.parametrize("frequency", [1e-6, 1.2e8]) def test_frequency(frequency): """ Test Agilent 33500 frequency function """ with expected_protocol( Agilent33500, [ ("SOUR1:FREQ?", frequency), ("SOUR2:FREQ?", frequency), ("FREQ?", frequency), (f"SOUR1:FREQ {frequency:.6f}", None), (f"SOUR2:FREQ {frequency:.6f}", None), (f"FREQ {frequency:.6f}", None), ], ) as inst: assert frequency == inst.ch_1.frequency assert frequency == inst.ch_2.frequency assert frequency == inst.frequency inst.ch_1.frequency = frequency inst.ch_2.frequency = frequency inst.frequency = frequency @pytest.mark.parametrize("amplitude", [10e-3, 10]) def test_amplitude(amplitude): """ Test Agilent 33500 amplitude function """ with expected_protocol( Agilent33500, [ ("SOUR1:VOLT?", amplitude), ("SOUR2:VOLT?", amplitude), ("VOLT?", amplitude), (f"SOUR1:VOLT {amplitude:.6f}", None), (f"SOUR2:VOLT {amplitude:.6f}", None), (f"VOLT {amplitude:.6f}", None), ], ) as inst: assert amplitude == inst.ch_1.amplitude assert amplitude == inst.ch_2.amplitude assert amplitude == inst.amplitude inst.ch_1.amplitude = amplitude inst.ch_2.amplitude = amplitude inst.amplitude = amplitude @pytest.mark.parametrize("amplitude_unit", ["VPP", "VRMS", "DBM"]) def test_amplitude_unit(amplitude_unit): """ Test Agilent 33500 amplitude unit function """ with expected_protocol( Agilent33500, [ ("SOUR1:VOLT:UNIT?", amplitude_unit), ("SOUR2:VOLT:UNIT?", amplitude_unit), ("VOLT:UNIT?", amplitude_unit), (f"SOUR1:VOLT:UNIT {amplitude_unit}", None), (f"SOUR2:VOLT:UNIT {amplitude_unit}", None), (f"VOLT:UNIT {amplitude_unit}", None), ], ) as inst: assert amplitude_unit == inst.ch_1.amplitude_unit assert amplitude_unit == inst.ch_2.amplitude_unit assert amplitude_unit == inst.amplitude_unit inst.ch_1.amplitude_unit = amplitude_unit inst.ch_2.amplitude_unit = amplitude_unit inst.amplitude_unit = amplitude_unit @pytest.mark.parametrize("state", [0, 1]) def test_output(state): """ Test Agilent 33500 output function """ with expected_protocol( Agilent33500, [ ("OUTP1?", state), ("OUTP2?", state), ("OUTP?", state), (f"OUTP1 {state}", None), (f"OUTP2 {state}", None), (f"OUTP {state}", None), ], ) as inst: assert state == inst.ch_1.output assert state == inst.ch_2.output assert state == inst.output inst.ch_1.output = state inst.ch_2.output = state inst.output = state @pytest.mark.parametrize("offset", [-4.995, 4.995]) def test_offset(offset): """ Test Agilent 33500 offset function """ with expected_protocol( Agilent33500, [ ("SOUR1:VOLT:OFFS?", offset), ("SOUR2:VOLT:OFFS?", offset), ("VOLT:OFFS?", offset), (f"SOUR1:VOLT:OFFS {offset:.6f}", None), (f"SOUR2:VOLT:OFFS {offset:.6f}", None), (f"VOLT:OFFS {offset:.6f}", None), ], ) as inst: assert offset == inst.ch_1.offset assert offset == inst.ch_2.offset assert offset == inst.offset inst.ch_1.offset = offset inst.ch_2.offset = offset inst.offset = offset @pytest.mark.parametrize("voltage_high", [-4.995, 4.995]) def test_voltage_high(voltage_high): """ Test Agilent 33500 voltage_high function """ with expected_protocol( Agilent33500, [ ("SOUR1:VOLT:HIGH?", voltage_high), ("SOUR2:VOLT:HIGH?", voltage_high), ("VOLT:HIGH?", voltage_high), (f"SOUR1:VOLT:HIGH {voltage_high:.6f}", None), (f"SOUR2:VOLT:HIGH {voltage_high:.6f}", None), (f"VOLT:HIGH {voltage_high:.6f}", None), ], ) as inst: assert voltage_high == inst.ch_1.voltage_high assert voltage_high == inst.ch_2.voltage_high assert voltage_high == inst.voltage_high inst.ch_1.voltage_high = voltage_high inst.ch_2.voltage_high = voltage_high inst.voltage_high = voltage_high @pytest.mark.parametrize("voltage_low", [-4.995, 4.995]) def test_voltage_low(voltage_low): """ Test Agilent 33500 voltage_low function """ with expected_protocol( Agilent33500, [ ("SOUR1:VOLT:LOW?", voltage_low), ("SOUR2:VOLT:LOW?", voltage_low), ("VOLT:LOW?", voltage_low), (f"SOUR1:VOLT:LOW {voltage_low:.6f}", None), (f"SOUR2:VOLT:LOW {voltage_low:.6f}", None), (f"VOLT:LOW {voltage_low:.6f}", None), ], ) as inst: assert voltage_low == inst.ch_1.voltage_low assert voltage_low == inst.ch_2.voltage_low assert voltage_low == inst.voltage_low inst.ch_1.voltage_low = voltage_low inst.ch_2.voltage_low = voltage_low inst.voltage_low = voltage_low @pytest.mark.parametrize("phase", [-360, 360]) def test_phase(phase): """ Test Agilent 33500 phase function """ with expected_protocol( Agilent33500, [ ("SOUR1:PHAS?", phase), ("SOUR2:PHAS?", phase), ("PHAS?", phase), (f"SOUR1:PHAS {phase:.6f}", None), (f"SOUR2:PHAS {phase:.6f}", None), (f"PHAS {phase:.6f}", None), ], ) as inst: assert phase == inst.ch_1.phase assert phase == inst.ch_2.phase assert phase == inst.phase inst.ch_1.phase = phase inst.ch_2.phase = phase inst.phase = phase @pytest.mark.parametrize("square_dutycycle", [0.01, 99.98]) def test_square_dutycycle(square_dutycycle): """ Test Agilent 33500 square_dutycycle function """ with expected_protocol( Agilent33500, [ ("SOUR1:FUNC:SQU:DCYC?", square_dutycycle), ("SOUR2:FUNC:SQU:DCYC?", square_dutycycle), ("FUNC:SQU:DCYC?", square_dutycycle), (f"SOUR1:FUNC:SQU:DCYC {square_dutycycle:.6f}", None), (f"SOUR2:FUNC:SQU:DCYC {square_dutycycle:.6f}", None), (f"FUNC:SQU:DCYC {square_dutycycle:.6f}", None), ], ) as inst: assert square_dutycycle == inst.ch_1.square_dutycycle assert square_dutycycle == inst.ch_2.square_dutycycle assert square_dutycycle == inst.square_dutycycle inst.ch_1.square_dutycycle = square_dutycycle inst.ch_2.square_dutycycle = square_dutycycle inst.square_dutycycle = square_dutycycle @pytest.mark.parametrize("ramp_symmetry", [0.01, 99.98]) def test_ramp_symmetry(ramp_symmetry): """ Test Agilent 33500 ramp_symmetry function """ with expected_protocol( Agilent33500, [ ("SOUR1:FUNC:RAMP:SYMM?", ramp_symmetry), ("SOUR2:FUNC:RAMP:SYMM?", ramp_symmetry), ("FUNC:RAMP:SYMM?", ramp_symmetry), (f"SOUR1:FUNC:RAMP:SYMM {ramp_symmetry:.6f}", None), (f"SOUR2:FUNC:RAMP:SYMM {ramp_symmetry:.6f}", None), (f"FUNC:RAMP:SYMM {ramp_symmetry:.6f}", None), ], ) as inst: assert ramp_symmetry == inst.ch_1.ramp_symmetry assert ramp_symmetry == inst.ch_2.ramp_symmetry assert ramp_symmetry == inst.ramp_symmetry inst.ch_1.ramp_symmetry = ramp_symmetry inst.ch_2.ramp_symmetry = ramp_symmetry inst.ramp_symmetry = ramp_symmetry def test_channel_phase_synchronization(): """ Test Agilent 33500 channel phase synchronization """ with expected_protocol( Agilent33500, [ ("PHAS:SYNC", None) ] ) as inst: assert inst.phase_sync() is None