# # 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. # from datetime import datetime import pytest from pymeasure.test import expected_protocol from pymeasure.instruments.hp import HP8560A, HP8561B from pymeasure.instruments.hp.hp856Xx import Trace, MixerMode, CouplingMode, DemodulationMode, \ DetectionModes, AmplitudeUnits, HP856Xx, ErrorCode, FrequencyReference, PeakSearchMode, \ StatusRegister, SourceLevelingControlMode, SweepCoupleMode, SweepOut, TraceDataFormat, \ TriggerMode, WindowType class TestHP856Xx: def test_id(self): with expected_protocol( HP856Xx, [("ID?", "HP8560A,002,H03")], ) as instr: assert instr.id == "HP8560A,002,H03" def test_attenuation(self): with expected_protocol( HP856Xx, [("AT 70", None), ("AT?", "70")], ) as instr: # test set and get of attenuation as integer instr.attenuation = 70 assert instr.attenuation == 70 def test_attenuation_string_parameters(self): with expected_protocol( HP856Xx, [("AT AUTO", None), ("AT?", "20"), ], ) as instr: # test string parameters instr.attenuation = "AUTO" assert instr.attenuation == 20 def test_attenuation_truncation(self): with expected_protocol( HP856Xx, [("AT 20", None), ("AT?", "20")], ) as instr: instr.attenuation = 16 assert instr.attenuation == 20 @pytest.mark.parametrize("amplitude_unit", [e for e in AmplitudeUnits]) def test_amplitude_units(self, amplitude_unit): with expected_protocol( HP856Xx, [("AUNITS " + amplitude_unit, None), ("AUNITS?", amplitude_unit)], ) as instr: instr.amplitude_unit = amplitude_unit assert instr.amplitude_unit == amplitude_unit @pytest.mark.parametrize( "function, command", [ ("set_auto_couple", "AUTOCPL"), ("exchange_traces", "AXB"), ("subtract_display_line_from_trace_b", "BML"), ("set_continuous_sweep", "CONTS"), ("set_full_span", "FS"), ("set_linear_scale", "LN"), ("set_marker_to_center_frequency", "MKCF"), ("set_marker_minimum", "MKMIN"), ("set_marker_to_reference_level", "MKRL"), ("set_marker_delta_to_span", "MKSP"), ("set_marker_to_center_frequency_step_size", "MKSS"), ("preset", "IP"), ("recall_open_short_average", "RCLOSCAL"), ("recall_thru", "RCLTHRU"), ("sweep_single", "SNGLS"), ("store_open", "STOREOPEN"), ("store_short", "STORESHORT"), ("store_thru", "STORETHRU"), ("adjust_all", "ADJALL"), ("set_crt_adjustment_pattern", "ADJCRT"), ("trigger_sweep", "TS"), ] ) def test_primitive_commands(self, command, function): """ Tests primitive commands which have no parameter or query derivat """ with expected_protocol( HP856Xx, [(command, None)] ) as instr: getattr(instr, function)() @pytest.mark.parametrize("trace", [e for e in Trace]) def test_blank_trace(self, trace): with expected_protocol( HP856Xx, [("BLANK " + trace, None)] ) as instr: instr.blank_trace(trace) def test_blank_trace_exceptions(self): with expected_protocol( HP856Xx, [] ) as instr: with pytest.raises(ValueError): instr.blank_trace("TEST") with pytest.raises(TypeError): instr.blank_trace(0) @pytest.mark.parametrize("function, command", [ ("start_frequency", "FA"), ("center_frequency", "CF"), ("stop_frequency", "FB"), ("frequency_offset", "FOFFSET"), ("span", "SP") ]) @pytest.mark.parametrize("hp_derivat, max_freq", [(HP8560A, 2.9e9), (HP8561B, 6.5e9)]) def test_frequencies(self, function, command, hp_derivat, max_freq): with expected_protocol( hp_derivat, [("%s %.11E Hz" % (command, max_freq), None), ("%s?" % command, '%.11E' % max_freq)] ) as instr: setattr(instr, function, max_freq) assert getattr(instr, function) == max_freq @pytest.mark.parametrize("trace", [e for e in Trace]) def test_clear_write_trace(self, trace): with expected_protocol( HP856Xx, [("CLRW " + trace, None)] ) as instr: instr.clear_write_trace(trace) def test_clear_write_trace_exceptions(self): with expected_protocol( HP856Xx, [] ) as instr: with pytest.raises(ValueError): instr.clear_write_trace("TEST") with pytest.raises(TypeError): instr.clear_write_trace(0) @pytest.mark.parametrize("coupling", [e for e in CouplingMode]) def test_coupling(self, coupling): with expected_protocol( HP856Xx, [("COUPLE " + coupling, None), ("COUPLE?", coupling)] ) as instr: instr.coupling = coupling assert instr.coupling == coupling @pytest.mark.parametrize("demod_mode", [e for e in DemodulationMode]) def test_demodulation_mode(self, demod_mode): with expected_protocol( HP856Xx, [("DEMOD " + demod_mode, None), ("DEMOD?", demod_mode)] ) as instr: instr.demodulation_mode = demod_mode assert instr.demodulation_mode == demod_mode @pytest.mark.parametrize("on_off, boole", [("1", True), ("0", False)]) def test_demodulation_agc_enabled(self, on_off, boole): with expected_protocol( HP856Xx, [("DEMODAGC " + on_off, None), ("DEMODAGC?", on_off)] ) as instr: instr.demodulation_agc_enabled = boole assert instr.demodulation_agc_enabled == boole def test_demodulation_time(self): with expected_protocol( HP856Xx, [("DEMODT 1.02000000000E+01", None), ("DEMODT?", "1.03000000000E+01")] ) as instr: instr.demodulation_time = 10.2 assert instr.demodulation_time == 10.3 @pytest.mark.parametrize("detector_mode", [e for e in DetectionModes]) def test_detector_mode(self, detector_mode): with expected_protocol( HP856Xx, [("DET " + detector_mode, None), ("DET?", detector_mode)] ) as instr: instr.detector_mode = detector_mode assert instr.detector_mode == detector_mode @pytest.mark.parametrize("string_params", ["ON", "OFF"]) def test_display_line_enabled(self, string_params): with expected_protocol( HP856Xx, [ ("DL " + string_params, None) ] ) as instr: instr.display_line_enabled = True if string_params == "ON" else False def test_check_done(self): with expected_protocol( HP856Xx, [("DONE?", "1")], ) as instr: instr.check_done() def test_errors(self): with expected_protocol( HP856Xx, [("ERR?", "112,101,111")], ) as instr: assert instr.errors == [ErrorCode(112), ErrorCode(101), ErrorCode(111)] def test_elapsed_time(self): with expected_protocol( HP856Xx, [("EL?", "1800")], ) as instr: assert instr.elapsed_time == 1800 @pytest.mark.parametrize( "function, command", [ ("sampling_frequency", "SMP"), ("lo_frequency", "LO"), ("mroll_frequency", "MROLL"), ("oroll_frequency", "OROLL"), ("xroll_frequency", "XROLL") ] ) def test_fdiag_frequencies(self, function, command): with expected_protocol( HP856Xx, [("FDIAG %s,?" % command, '%.11E' % 2.8E8)] ) as instr: assert getattr(instr, function) == 2.8E8 def test_sampler_harmonic_number(self): with expected_protocol( HP856Xx, [("FDIAG HARM,?", '%.11E' % 1.40000000000E1)] ) as instr: assert instr.sampler_harmonic_number == 14 def test_frequency_display_enabled(self): with expected_protocol( HP856Xx, [("FDSP?", "0")] ) as instr: assert instr.frequency_display_enabled is False def test_fft(self): with expected_protocol( HP856Xx, [("FFT TRA,TRB,TRA", None)] ) as instr: instr.do_fft(Trace.A, Trace.B, Trace.A) def test_fft_exceptions(self): with expected_protocol( HP856Xx, [] ) as instr: with pytest.raises(TypeError): instr.do_fft(0, 4, 5) with pytest.raises(ValueError): instr.do_fft("TRAZ", "zuo", "TEWST") @pytest.mark.parametrize("frequency_reference", [e for e in FrequencyReference]) def test_frequency_reference_source(self, frequency_reference): with expected_protocol( HP856Xx, [("FREF " + frequency_reference, None), ("FREF?", frequency_reference)] ) as instr: instr.frequency_reference_source = frequency_reference assert instr.frequency_reference_source == frequency_reference @pytest.mark.parametrize( "function, command", [ ("graticule_enabled", "GRAT"), ("marker_signal_tracking_enabled", "MKTRACK"), ("marker_noise_mode_enabled", "MKNOISE"), ("normalize_trace_data_enabled", "NORMLIZE"), ("protect_state_enabled", "PSTATE"), ("trace_a_minus_b_enabled", "AMB"), ("trace_a_minus_b_plus_dl_enabled", "AMBPL"), ("annotation_enabled", "ANNOT") ] ) def test_on_off_commands(self, function, command): with expected_protocol( HP856Xx, [(command + " 0", None), (command + "?", "1")] ) as instr: setattr(instr, function, False) assert getattr(instr, function) is True @pytest.mark.parametrize("cmd", ["CURR", "FULL"]) def test_adjust_if(self, cmd): with expected_protocol( HP856Xx, [("ADJIF 1", None), ("ADJIF %s" % cmd, None), ("ADJIF?", "1")] ) as instr: instr.adjust_if = True instr.adjust_if = cmd assert instr.adjust_if is True def test_logarithmic_scale(self): with expected_protocol( HP856Xx, [("LG 1 DB", None), ("LG?", "10")] ) as instr: instr.logarithmic_scale = 1 assert instr.logarithmic_scale == 10 @pytest.mark.parametrize( "function, cmdstr", [ ("set_minimum_hold", "MINH"), ("set_maximum_hold", "MXMH") ] ) @pytest.mark.parametrize("trace", [e for e in Trace]) def test_hold(self, trace, function, cmdstr): with expected_protocol( HP856Xx, [(cmdstr + " " + trace, None)] ) as instr: getattr(instr, function)(trace) @pytest.mark.parametrize("function", ["set_minimum_hold", "set_maximum_hold"]) def test_hold_exceptions(self, function): with expected_protocol( HP856Xx, [] ) as instr: with pytest.raises(ValueError): getattr(instr, function)("TEST") with pytest.raises(TypeError): getattr(instr, function)(0) def test_marker_amplitude(self): with expected_protocol( HP856Xx, [("MKA?", 2.8e7)] ) as instr: assert instr.marker_amplitude == 2.8e7 def test_marker_delta(self): with expected_protocol( HP856Xx, [ ("MKD %.11E Hz" % 28, None), ("MKD?", 2.8e7) ] ) as instr: instr.marker_delta = 2.8e1 assert instr.marker_delta == 2.8e7 def test_marker_frequency(self): with expected_protocol( HP856Xx, [ ("MKF %.11E Hz" % 1, None), ("MKF?", 0.5) ] ) as instr: instr.marker_frequency = 1 assert instr.marker_frequency == 0.5 def test_frequency_counter_mode_enabled(self): with expected_protocol( HP856Xx, [ ("MKFC OFF", None), ("MKFC ON", None) ] ) as instr: instr.frequency_counter_mode_enabled = False instr.frequency_counter_mode_enabled = True def test_frequency_counter_resolution(self): with expected_protocol( HP856Xx, [ ("MKFCR %d Hz" % 1e3, None), ("MKFCR?", 1e4) ] ) as instr: instr.frequency_counter_resolution = 1e3 assert instr.frequency_counter_resolution == 1e4 @pytest.mark.parametrize("all_markers, cmdstring", [(True, " ALL"), (False, "")]) def test_deactivate_marker(self, all_markers, cmdstring): with expected_protocol( HP856Xx, [ ("MKOFF%s" % cmdstring, None), ] ) as instr: instr.deactivate_marker(all_markers) @pytest.mark.parametrize("mode", [e for e in PeakSearchMode]) def test_minimum_hold(self, mode): with expected_protocol( HP856Xx, [("MKPK " + mode, None)] ) as instr: instr.search_peak(mode) def test_marker_threshold(self): with expected_protocol( HP856Xx, [ ("AUNITS?", "DBM"), ("MKPT %d DBM" % -30, None), ("MKPT?", -70) ] ) as instr: instr.marker_threshold = -30 assert instr.marker_threshold == -70 def test_peak_excursion(self): with expected_protocol( HP856Xx, [ ("MKPX %g DB" % 10.3, None), ("MKPX?", 10.3) ] ) as instr: instr.peak_excursion = 10.3 assert instr.peak_excursion == 10.3 def test_marker_time(self): with expected_protocol( HP856Xx, [ ("MKT %gS" % 10.3, None), ("MKT?", 10.3) ] ) as instr: instr.marker_time = 10.3 assert instr.marker_time == 10.3 def test_mixer_level(self): with expected_protocol( HP856Xx, [ ("ML -30 DB", None), ("ML?", "-30") ] ) as instr: instr.mixer_level = -30 assert instr.mixer_level == -30 def test_normalized_reference_level(self): with expected_protocol( HP856Xx, [ ("AUNITS?", "DBM"), ("NRL -30 DBM", None), ("NRL?", "-30") ] ) as instr: instr.normalized_reference_level = -30 assert instr.normalized_reference_level == -30 def test_normalized_reference_position(self): with expected_protocol( HP856Xx, [ ("NRPOS 8.000000 DB", None), ("NRPOS?", "8") ] ) as instr: instr.normalized_reference_position = 8 assert instr.normalized_reference_position == 8 def test_display_parameters(self): with expected_protocol( HP856Xx, [ ("OP?", "72,16,712,766") ] ) as instr: assert instr.display_parameters == (72, 16, 712, 766) def test_plot(self): with expected_protocol( HP856Xx, [ ("PLOT 72,16,712,766", None) ] ) as instr: instr.plot(72, 16, 712, 766) def test_power_bandwidth(self): with expected_protocol( HP856Xx, [ ("PWRBW TRA,99.2?", "1.0e3") ] ) as instr: assert instr.get_power_bandwidth(Trace.A, 99.2) == 1e3 def test_resolution_bandwidth(self): with expected_protocol( HP856Xx, [ ("RB 30 Hz", None), ("RB AUTO", None), ("RB?", "30") ] ) as instr: instr.resolution_bandwidth = 30 instr.resolution_bandwidth = "AUTO" assert instr.resolution_bandwidth == 30 def test_resolution_bandwidth_to_span_ratio(self): with expected_protocol( HP856Xx, [ ("RBR 0.014", None), ("RBR?", "0.014") ] ) as instr: instr.resolution_bandwidth_to_span_ratio = 0.0140 assert instr.resolution_bandwidth_to_span_ratio == 0.0140 def test_recall_state(self): with expected_protocol( HP856Xx, [ ("RCLS LAST", None), ("RCLS 8", None) ] ) as instr: instr.recall_state("LAST") instr.recall_state(8) def test_recall_trace(self): with expected_protocol( HP856Xx, [ ("RCLT TRA,6", None) ] ) as instr: instr.recall_trace(Trace.A, 6) def test_firmware_revision(self): with expected_protocol( HP856Xx, [ ("REV?", "901101") ] ) as instr: assert instr.firmware_revision == datetime.strptime("11-01-1990", '%m-%d-%Y').date() def test_reference_level(self): with expected_protocol( HP856Xx, [ ("AUNITS?", "DBM"), ("RL 10 DBM", None), ("RL?", "10") ] ) as instr: instr.reference_level = 10 assert instr.reference_level == 10 def test_reference_level_calibration(self): with expected_protocol( HP856Xx, [ ("RLCAL 33", None), ("RLCAL?", "33") ] ) as instr: instr.reference_level_calibration = 33 assert instr.reference_level_calibration == 33 def test_request_service_conditions(self): with expected_protocol( HP856Xx, [ ("RQS 48", None), ("RQS?", "48") ] ) as instr: instr.request_service_conditions = \ StatusRegister.COMMAND_COMPLETE | StatusRegister.ERROR_PRESENT assert instr.request_service_conditions == \ StatusRegister.COMMAND_COMPLETE | StatusRegister.ERROR_PRESENT def test_save_state(self): with expected_protocol( HP856Xx, [ ("SAVES 6", None) ] ) as instr: instr.save_state(6) def test_save_trace(self): with expected_protocol( HP856Xx, [ ("SAVET TRA,6", None) ] ) as instr: instr.save_trace(Trace.A, 6) @pytest.mark.parametrize("param", ["FULL", "ZERO"]) def test_span_string_params(self, param): with expected_protocol( HP856Xx, [ ("SP %s" % param, None) ] ) as instr: instr.span = param @pytest.mark.parametrize("string_params", ["ON", "OFF"]) def test_squelch(self, string_params): with expected_protocol( HP856Xx, [("AUNITS?", "DBM"), ("SQUELCH 10 DBM", None), ("SQUELCH %s" % string_params, None), ("SQUELCH?", "10")] ) as instr: instr.squelch = 10 instr.squelch = string_params assert instr.squelch == 10 def test_service_request(self): with expected_protocol( HP856Xx, [ ("SRQ 48", None) ] ) as instr: instr.request_service(StatusRegister.COMMAND_COMPLETE | StatusRegister.ERROR_PRESENT) def test_sweep_time(self): with expected_protocol( HP856Xx, [("ST 10.000 S", None), ("ST AUTO", None), ("ST?", "10.00")] ) as instr: instr.sweep_time = 10 instr.sweep_time = "AUTO" assert instr.sweep_time == 10 @pytest.mark.parametrize("mode", [e for e in SweepCoupleMode]) def test_sweep_couple(self, mode): with expected_protocol( HP856Xx, [("SWPCPL " + mode, None), ("SWPCPL?", mode)] ) as instr: instr.sweep_couple = mode assert instr.sweep_couple == mode @pytest.mark.parametrize("mode", [e for e in SweepOut]) def test_sweep_output(self, mode): with expected_protocol( HP856Xx, [("SWPOUT " + mode, None), ("SWPOUT?", mode)] ) as instr: instr.sweep_output = mode assert instr.sweep_output == mode @pytest.mark.parametrize("mode", [e for e in TraceDataFormat]) def test_trace_data_format(self, mode): with expected_protocol( HP856Xx, [("TDF " + mode, None), ("TDF?", mode)] ) as instr: instr.trace_data_format = mode assert instr.trace_data_format == mode def test_threshold(self): with expected_protocol( HP856Xx, [("AUNITS?", "DBM"), ("TH 1.00E+01 DBM", None), ("TH?", "10.00")] ) as instr: instr.threshold = 10 assert instr.threshold == 10 def test_threshold_enabled(self): with expected_protocol( HP856Xx, [("TH ON", None)] ) as instr: instr.threshold_enabled = True def test_title(self): with expected_protocol( HP856Xx, [("TITLE@%s@" % "TestString", None)] ) as instr: instr.set_title("TestString") @pytest.mark.parametrize("mode", [e for e in TriggerMode]) def test_trigger_mode(self, mode): with expected_protocol( HP856Xx, [("TM " + mode, None), ("TM?", mode)] ) as instr: instr.trigger_mode = mode assert instr.trigger_mode == mode @pytest.mark.parametrize("function, cmd", [ ("get_trace_data_a", "TRA"), ("get_trace_data_b", "TRB") ]) def test_trace_data(self, function, cmd): data = [48, 61, 31, 73, 90, 82, 56, 48, 87, 78, 59, 103, 78, 76, 92, 52, 57, 72, 48, 82, 108, 63, 52, 79, 44, 88, 95, 99, 74, 79, 63, 100, 51, 85, 96, 69, 97, 50, 105, 94, 58, 98, 92, 92, 96, 59, 63, 34, 81, 56, 50, 94, 74, 61, 40, 48, 72, 69, 86, 114, 59, 70, 83, 53, 67, 111, 110, 99, 112, 72, 100, 44, 80, 81, 65, 34, 56, 62, 55, 78, 86, 68, 59, 66, 91, 91, 91, 63, 83, 90, 71, 94, 91, 46, 69, 70, 99, 52, 86, 63, 88, 75, 55, 80, 97, 31, 40, 81, 92, 75, 30, 113, 83, 64, 98, 49, 51, 99, 102, 54, 57, 38, 67, 84, 75, 59, 75, 78, 93, 47, 89, 107, 77, 42, 63, 98, 45, 81, 81, 98, 39, 39, 44, 89, 72, 77, 99, 104, 84, 61, 105, 76, 80, 29, 66, 45, 88, 98, 54, 108, 89, 88, 54, 79, 91, 38, 85, 98, 42, 66, 41, 94, 55, 49, 94, 57, 67, 69, 75, 96, 87, 75, 97, 101, 52, 85, 76, 47, 53, 108, 61, 82, 61, 61, 64, 56, 88, 62, 54, 91, 54, 38, 37, 91, 65, 60, 60, 70, 102, 97, 71, 93, 85, 92, 52, 85, 61, 77, 63, 96, 71, 40, 51, 65, 69, 78, 65, 81, 56, 63, 68, 59, 43, 120, 77, 58, 57, 79, 90, 62, 47, 50, 76, 77, 87, 38, 102, 72, 66, 74, 84, 73, 70, 64, 88, 86, 73, 83, 82, 98, 98, 93, 100, 114, 111, 116, 121, 127, 132, 139, 148, 153, 160, 167, 174, 182, 190, 197, 205, 215, 224, 233, 244, 255, 265, 275, 287, 300, 313, 325, 339, 354, 368, 383, 397, 414, 429, 443, 455, 466, 472, 475, 474, 468, 458, 447, 434, 417, 402, 388, 373, 357, 343, 329, 316, 303, 291, 279, 269, 259, 248, 239, 230, 220, 212, 204, 196, 189, 181, 175, 168, 162, 154, 147, 143, 136, 128, 124, 120, 113, 104, 104, 98, 92, 86, 115, 96, 86, 112, 77, 92, 88, 82, 79, 104, 49, 97, 73, 58, 68, 80, 84, 68, 78, 46, 74, 88, 81, 110, 80, 82, 89, 83, 50, 62, 64, 97, 58, 48, 66, 47, 53, 38, 108, 94, 88, 116, 66, 103, 85, 41, 63, 81, 58, 118, 50, 110, 93, 52, 43, 74, 42, 89, 71, 66, 50, 73, 89, 119, 86, 57, 100, 55, 79, 71, 75, 90, 47, 86, 79, 110, 99, 87, 79, 87, 63, 76, 73, 62, 98, 107, 89, 80, 90, 71, 44, 46, 50, 41, 66, 109, 47, 97, 70, 77, 75, 103, 120, 69, 67, 92, 90, 81, 54, 95, 97, 86, 83, 71, 48, 53, 95, 62, 51, 85, 59, 71, 90, 63, 69, 108, 72, 75, 25, 116, 60, 51, 90, 84, 74, 43, 88, 83, 60, 99, 86, 61, 72, 82, 77, 80, 64, 84, 101, 108, 57, 107, 92, 77, 62, 81, 74, 69, 50, 46, 56, 51, 79, 49, 34, 101, 76, 55, 111, 103, 92, 109, 123, 74, 50, 68, 56, 79, 43, 55, 43, 111, 46, 76, 103, 85, 70, 53, 70, 88, 54, 117, 78, 85, 57, 72, 88, 89, 58, 98, 55, 68, 77, 71, 56, 75, 44, 53, 76, 95, 81, 48, 40, 84, 38, 84, 110, 82, 67, 114, 79, 40, 52, 102, 103, 85, 80, 108, 86, 40, 123, 66, 86, 93, 83, 78, 42, 74, 33, 79, 55, 67, 111, 77, 61, 89, 58, 89, 103, 77, 77, 62, 57, 61, 54, 30] expected_data = [-82.0, -79.83, -84.83, -77.83, -75.0, -76.33, -80.67, -82.0, -75.5, -77.0, -80.17, -72.83, -77.0, -77.33, -74.67, -81.33, -80.5, -78.0, -82.0, -76.33, -72.0, -79.5, -81.33, -76.83, -82.67, -75.33, -74.17, -73.5, -77.67, -76.83, -79.5, -73.33, -81.5, -75.83, -74.0, -78.5, -73.83, -81.67, -72.5, -74.33, -80.33, -73.67, -74.67, -74.67, -74.0, -80.17, -79.5, -84.33, -76.5, -80.67, -81.67, -74.33, -77.67, -79.83, -83.33, -82.0, -78.0, -78.5, -75.67, -71.0, -80.17, -78.33, -76.17, -81.17, -78.83, -71.5, -71.67, -73.5, -71.33, -78.0, -73.33, -82.67, -76.67, -76.5, -79.17, -84.33, -80.67, -79.67, -80.83, -77.0, -75.67, -78.67, -80.17, -79.0, -74.83, -74.83, -74.83, -79.5, -76.17, -75.0, -78.17, -74.33, -74.83, -82.33, -78.5, -78.33, -73.5, -81.33, -75.67, -79.5, -75.33, -77.5, -80.83, -76.67, -73.83, -84.83, -83.33, -76.5, -74.67, -77.5, -85.0, -71.17, -76.17, -79.33, -73.67, -81.83, -81.5, -73.5, -73.0, -81.0, -80.5, -83.67, -78.83, -76.0, -77.5, -80.17, -77.5, -77.0, -74.5, -82.17, -75.17, -72.17, -77.17, -83.0, -79.5, -73.67, -82.5, -76.5, -76.5, -73.67, -83.5, -83.5, -82.67, -75.17, -78.0, -77.17, -73.5, -72.67, -76.0, -79.83, -72.5, -77.33, -76.67, -85.17, -79.0, -82.5, -75.33, -73.67, -81.0, -72.0, -75.17, -75.33, -81.0, -76.83, -74.83, -83.67, -75.83, -73.67, -83.0, -79.0, -83.17, -74.33, -80.83, -81.83, -74.33, -80.5, -78.83, -78.5, -77.5, -74.0, -75.5, -77.5, -73.83, -73.17, -81.33, -75.83, -77.33, -82.17, -81.17, -72.0, -79.83, -76.33, -79.83, -79.83, -79.33, -80.67, -75.33, -79.67, -81.0, -74.83, -81.0, -83.67, -83.83, -74.83, -79.17, -80.0, -80.0, -78.33, -73.0, -73.83, -78.17, -74.5, -75.83, -74.67, -81.33, -75.83, -79.83, -77.17, -79.5, -74.0, -78.17, -83.33, -81.5, -79.17, -78.5, -77.0, -79.17, -76.5, -80.67, -79.5, -78.67, -80.17, -82.83, -70.0, -77.17, -80.33, -80.5, -76.83, -75.0, -79.67, -82.17, -81.67, -77.33, -77.17, -75.5, -83.67, -73.0, -78.0, -79.0, -77.67, -76.0, -77.83, -78.33, -79.33, -75.33, -75.67, -77.83, -76.17, -76.33, -73.67, -73.67, -74.5, -73.33, -71.0, -71.5, -70.67, -69.83, -68.83, -68.0, -66.83, -65.33, -64.5, -63.33, -62.17, -61.0, -59.67, -58.33, -57.17, -55.83, -54.17, -52.67, -51.17, -49.33, -47.5, -45.83, -44.17, -42.17, -40.0, -37.83, -35.83, -33.5, -31.0, -28.67, -26.17, -23.83, -21.0, -18.5, -16.17, -14.17, -12.33, -11.33, -10.83, -11.0, -12.0, -13.67, -15.5, -17.67, -20.5, -23.0, -25.33, -27.83, -30.5, -32.83, -35.17, -37.33, -39.5, -41.5, -43.5, -45.17, -46.83, -48.67, -50.17, -51.67, -53.33, -54.67, -56.0, -57.33, -58.5, -59.83, -60.83, -62.0, -63.0, -64.33, -65.5, -66.17, -67.33, -68.67, -69.33, -70.0, -71.17, -72.67, -72.67, -73.67, -74.67, -75.67, -70.83, -74.0, -75.67, -71.33, -77.17, -74.67, -75.33, -76.33, -76.83, -72.67, -81.83, -73.83, -77.83, -80.33, -78.67, -76.67, -76.0, -78.67, -77.0, -82.33, -77.67, -75.33, -76.5, -71.67, -76.67, -76.33, -75.17, -76.17, -81.67, -79.67, -79.33, -73.83, -80.33, -82.0, -79.0, -82.17, -81.17, -83.67, -72.0, -74.33, -75.33, -70.67, -79.0, -72.83, -75.83, -83.17, -79.5, -76.5, -80.33, -70.33, -81.67, -71.67, -74.5, -81.33, -82.83, -77.67, -83.0, -75.17, -78.17, -79.0, -81.67, -77.83, -75.17, -70.17, -75.67, -80.5, -73.33, -80.83, -76.83, -78.17, -77.5, -75.0, -82.17, -75.67, -76.83, -71.67, -73.5, -75.5, -76.83, -75.5, -79.5, -77.33, -77.83, -79.67, -73.67, -72.17, -75.17, -76.67, -75.0, -78.17, -82.67, -82.33, -81.67, -83.17, -79.0, -71.83, -82.17, -73.83, -78.33, -77.17, -77.5, -72.83, -70.0, -78.5, -78.83, -74.67, -75.0, -76.5, -81.0, -74.17, -73.83, -75.67, -76.17, -78.17, -82.0, -81.17, -74.17, -79.67, -81.5, -75.83, -80.17, -78.17, -75.0, -79.5, -78.5, -72.0, -78.0, -77.5, -85.83, -70.67, -80.0, -81.5, -75.0, -76.0, -77.67, -82.83, -75.33, -76.17, -80.0, -73.5, -75.67, -79.83, -78.0, -76.33, -77.17, -76.67, -79.33, -76.0, -73.17, -72.0, -80.5, -72.17, -74.67, -77.17, -79.67, -76.5, -77.67, -78.5, -81.67, -82.33, -80.67, -81.5, -76.83, -81.83, -84.33, -73.17, -77.33, -80.83, -71.5, -72.83, -74.67, -71.83, -69.5, -77.67, -81.67, -78.67, -80.67, -76.83, -82.83, -80.83, -82.83, -71.5, -82.33, -77.33, -72.83, -75.83, -78.33, -81.17, -78.33, -75.33, -81.0, -70.5, -77.0, -75.83, -80.5, -78.0, -75.33, -75.17, -80.33, -73.67, -80.83, -78.67, -77.17, -78.17, -80.67, -77.5, -82.67, -81.17, -77.33, -74.17, -76.5, -82.0, -83.33, -76.0, -83.67, -76.0, -71.67, -76.33, -78.83, -71.0, -76.83, -83.33, -81.33, -73.0, -72.83, -75.83, -76.67, -72.0, -75.67, -83.33, -69.5, -79.0, -75.67, -74.5, -76.17, -77.0, -83.0, -77.67, -84.5, -76.83, -80.83, -78.83, -71.5, -77.17, -79.83, -75.17, -80.33, -75.17, -72.83, -77.17, -77.17, -79.67, -80.5, -79.83, -81.0, -85.0] with expected_protocol( HP856Xx, [ ("TDF M", None), ("AUNITS?", "DBM"), ("RL?", "10.0"), ("LG?", "10.0"), (cmd + "?", ','.join([str(i) for i in data])) ] ) as instr: assert getattr(instr, function)() == expected_data def test_fft_trace_window(self): with expected_protocol( HP856Xx, [("TWNDOW TRA,FLATTOP", None)] ) as instr: instr.create_fft_trace_window(Trace.A, WindowType.Flattop) @pytest.mark.parametrize("param", [("ON", True), ("OFF", False)]) def test_video_average_enabled(self, param): str_param, boolean = param with expected_protocol( HP856Xx, [("VAVG " + str_param, None)] ) as instr: instr.video_average_enabled = boolean def test_video_bandwidth(self): with expected_protocol( HP856Xx, [("VB 70 Hz", None), ("VB?", "70")], ) as instr: instr.video_bandwidth = 70 assert instr.video_bandwidth == 70 def test_video_bandwidth_string_parameters(self): with expected_protocol( HP856Xx, [("VB AUTO", None), ("VB?", "20"), ], ) as instr: instr.video_bandwidth = "AUTO" assert instr.video_bandwidth == 20 def test_video_bandwidth_to_resolution_bandwidth(self): with expected_protocol( HP856Xx, [("VBR 0.005", None), ("VBR?", "0.005")], ) as instr: instr.video_bandwidth_to_resolution_bandwidth = 0.005 assert instr.video_bandwidth_to_resolution_bandwidth == 0.005 @pytest.mark.parametrize("trace", [e for e in Trace]) def test_view_trace(self, trace): with expected_protocol( HP856Xx, [("VIEW " + trace, None)] ) as instr: instr.view_trace(trace) def test_video_trigger_level(self): with expected_protocol( HP856Xx, [("AUNITS?", "DBM"), ("VTL -200.780 DBM", None), ("VTL?", "0.005")], ) as instr: instr.video_trigger_level = -200.78 assert instr.video_trigger_level == 0.005 class TestHP8560A: @pytest.mark.parametrize("mode", [e for e in SourceLevelingControlMode]) def test_source_leveling_control(self, mode): with expected_protocol( HP8560A, [("SRCALC " + mode, None), ("SRCALC?", mode)] ) as instr: instr.source_leveling_control = mode assert instr.source_leveling_control == mode def test_tracking_adjust_coarse(self): with expected_protocol( HP8560A, [("SRCCRSTK 10", None), ("SRCCRSTK?", "10")] ) as instr: instr.tracking_adjust_coarse = 10 assert instr.tracking_adjust_coarse == 10 def test_tracking_adjust_fine(self): with expected_protocol( HP8560A, [("SRCFINTK 10", None), ("SRCFINTK?", "10")] ) as instr: instr.tracking_adjust_fine = 10 assert instr.tracking_adjust_fine == 10 def test_source_power_offset(self): with expected_protocol( HP8560A, [("AUNITS?", "DBM"), ("SRCPOFS 10 DBM", None), ("SRCPOFS?", "10")] ) as instr: instr.source_power_offset = 10 assert instr.source_power_offset == 10 def test_source_power_step(self): with expected_protocol( HP8560A, [("SRCPSTP 10.10 DB", None), ("SRCPSTP?", "10.10")] ) as instr: instr.source_power_step = 10.1 assert instr.source_power_step == 10.1 def test_source_power_sweep(self): with expected_protocol( HP8560A, [("SRCPSWP 10.00 DB", None), ("SRCPSWP?", "10.00")] ) as instr: instr.source_power_sweep = 10 assert instr.source_power_sweep == 10 def test_source_power_sweep_enabled(self): with expected_protocol( HP8560A, [("SRCPSWP OFF", None)] ) as instr: instr.source_power_sweep_enabled = False def test_source_power(self): with expected_protocol( HP8560A, [("AUNITS?", "DBM"), ("SRCPWR 2.00 DBM", None), ("SRCPWR ON", None), ("SRCPWR?", "2.00")] ) as instr: instr.source_power = 2.0 instr.source_power = "ON" assert instr.source_power == 2.0 def test_source_peak_tracking(self): with expected_protocol( HP8560A, [("SRCTKPK", None)] ) as instr: instr.activate_source_peak_tracking() class TestHP8561B: @pytest.mark.parametrize("mixer_mode", [e for e in MixerMode]) def test_external_mixer(self, mixer_mode): with expected_protocol( HP8561B, [("MXRMODE " + mixer_mode, None), ("MXRMODE?", mixer_mode)] ) as instr: instr.mixer_mode = mixer_mode assert instr.mixer_mode == mixer_mode def test_conversion_loss(self): with expected_protocol( HP8561B, [("CNVLOSS 10.2 DB", None), ("CNVLOSS?", "10.3")] ) as instr: instr.conversion_loss = 10.2 assert instr.conversion_loss == 10.3 def test_fullband(self): with expected_protocol( HP8561B, [("FULLBAND K", None)] ) as instr: instr.set_fullband("K") def test_fullband_exceptions(self): with expected_protocol( HP8561B, [] ) as instr: with pytest.raises(TypeError): instr.set_fullband(1) with pytest.raises(ValueError): instr.set_fullband("Z") def test_harmonic_number_lock(self): with expected_protocol( HP8561B, [("HNLOCK 10", None), ("HNLOCK?", "10")] ) as instr: instr.harmonic_number_lock = 10 assert instr.harmonic_number_lock == 10 @pytest.mark.parametrize("params", [("ON", True), ("OFF", False)]) def test_harmonic_number_lock_enabled(self, params): str_param, boolean = params with expected_protocol( HP8561B, [("HNLOCK %s" % str_param, None)] ) as instr: instr.harmonic_number_lock_enabled = boolean @pytest.mark.parametrize( "function, command", [ ("unlock_harmonic_number", "HUNLK"), ("set_signal_identification_to_center_frequency", "IDCF"), ("peak_preselector", "PP") ] ) def test_primitive_commands(self, command, function): """ Tests primitive commands which have no parameter or query derivat """ with expected_protocol( HP8561B, [(command, None)] ) as instr: getattr(instr, function)() def test_signal_identification_frequency(self): with expected_protocol( HP8561B, [("IDFREQ?", 2.7897e9)] ) as instr: assert instr.signal_identification_frequency == 2.7897e9 def test_mixer_bias(self): with expected_protocol( HP8561B, [("MBIAS -9.900 MA", None), ("MBIAS?", "5.5")] ) as instr: instr.mixer_bias = -9.9 assert instr.mixer_bias == 5.5 @pytest.mark.parametrize("params", [("ON", True), ("OFF", False)]) def test_mixer_bias_enabled(self, params): str_param, boolean = params with expected_protocol( HP8561B, [("MBIAS %s" % str_param, None)] ) as instr: instr.mixer_bias_enabled = boolean def test_preselector_dac_number(self): with expected_protocol( HP8561B, [("PSDAC 10", None), ("PSDAC?", "10")] ) as instr: instr.preselector_dac_number = 10 assert instr.preselector_dac_number == 10 def test_signal_identification(self): with expected_protocol( HP8561B, [("SIGID AUTO", None), ("SIGID?", "1")] ) as instr: instr.signal_identification = "AUTO" assert instr.signal_identification is True