diff --git a/docs/changes/newsfragments/8697.breaking b/docs/changes/newsfragments/8697.breaking new file mode 100644 index 000000000000..7a1b7367c7db --- /dev/null +++ b/docs/changes/newsfragments/8697.breaking @@ -0,0 +1,11 @@ +The ``current``, ``current_range`` and ``current_limit`` parameters of the ``YokogawaGS200``, +and its ``measure`` parameter in voltage source mode, now use the unit ``A`` instead of ``I``. +The ``ramp_rate`` and ``ramp_step`` parameters now start with the units ``A/s`` and ``A`` +instead of ``V/s`` and ``V`` if the instrument is in current source mode when connecting, as +they already did after changing the source mode. + +``YokogawaGS200Monitor.delay`` (``measure.delay``) is now in seconds, the unit the instrument +uses, instead of ms. The value was already sent to the instrument unconverted, so +``delay(500)`` set a delay of 500 s despite the ``ms`` unit. The parameter now accepts values +from 0 to 999.999 s in steps of 1 ms, e.g. ``delay(0.5)`` for 500 ms, and returns the delay +as a ``float`` in seconds instead of an ``int`` rounded to whole seconds. diff --git a/docs/changes/newsfragments/8697.improved_driver b/docs/changes/newsfragments/8697.improved_driver new file mode 100644 index 000000000000..a89714ea9cd3 --- /dev/null +++ b/docs/changes/newsfragments/8697.improved_driver @@ -0,0 +1,16 @@ +The remaining parameters of the ``YokogawaGS200`` driver are now annotated with the type of +their value, e.g. ``Parameter[float, Self]``. ``YokogawaGS200Program.count`` is annotated as +``int | Literal["MIN", "MAX"]``: it can be set to ``"MIN"`` or ``"MAX"``, and getting it +always returns an integer, but until it is read again the cached value is the keyword that was +set. The status register parameters return the ``StatusByte``, ``StandardEventRegister``, +``ExtendedEventRegister`` and ``ConditionRegister`` flags as before, and are now annotated as +such. + +Fixed the following driver bugs found along the way: + +- ``YokogawaGS200.ramp_voltage`` and ``ramp_current`` raised a ``TypeError`` when called with + ``ramp_mode="SOFTWARE"``. They now perform the software ramp, and raise a ``ValueError`` if + ``ramp_step`` is 0, which would otherwise jump directly to the target. +- A software ramp of the ``YokogawaGS200`` to a target outside the output range of the present + source range now raises before changing the output. Previously it stepped up to the limit of + the range before raising. diff --git a/src/qcodes/instrument/sims/Yokogawa_GS200.yaml b/src/qcodes/instrument/sims/Yokogawa_GS200.yaml index 82ce6cb14428..b81544adea8f 100644 --- a/src/qcodes/instrument/sims/Yokogawa_GS200.yaml +++ b/src/qcodes/instrument/sims/Yokogawa_GS200.yaml @@ -11,8 +11,29 @@ devices: r: "QCoDeS Yokogawa Mock,GS200,xxxxxxxx,MOCKFW" - q: "*OPT?" r: "NO OPTIONS" + # Status registers, see GS200 User's Manual IM GS210-01EN, 13.3. + # *STB?: RQS (bit 6) and EAV (bit 2) + - &stb + q: "*STB?" + r: "68" + # *ESR?: CME (bit 5) + - &esr + q: "*ESR?" + r: "32" + # :STAT:EVEN?: EOP (bit 7) and SCG (bit 5) + - &stat_even + q: ":STAT:EVEN?" + r: "160" + # :STAT:COND?: RFP (bit 8) + - &stat_cond + q: ":STAT:COND?" + r: "256" + # Only queried when *STB? reports EAV, so always return an error. + - &syst_err + q: ":SYSTem:ERRor?" + r: '-222,"Data out of range"' - properties: + properties: &gs200_properties mode: default: "VOLT" getter: @@ -45,15 +66,83 @@ devices: q: ":SOUR:LEV {:e}" specs: type: float + # pyvisa-sim cannot convert MIN/MAX to the step numbers 1/10000 as the + # instrument does, so only set this to integers when reading it back. + program_count: + default: 1 + getter: + q: ":PROG:COUN?" + r: "{}" + setter: + q: ":PROG:COUN {}" auto_level: default: 0.0 setter: q: ":SOUR:LEV:AUTO {:e}" specs: type: float + # Measurement (/MON option) settings, only used by device 2 + measurement_enabled: + default: 0 + getter: + q: ":SENS?" + r: "{}" + setter: + q: ":SENS {}" + nplc: + default: "+1.0E+00" + getter: + q: ":SENS:NPLC?" + r: "{}" + setter: + q: ":SENS:NPLC {}" + measurement_delay: + default: "+0.0E+00" + getter: + q: ":SENS:DEL?" + r: "{}" + setter: + q: ":SENS:DEL {}" + measurement_trigger: + default: "READ" + getter: + q: ":SENS:TRIG?" + r: "{}" + setter: + q: ":SENS:TRIG {}" + measurement_interval: + default: "+0.5E+00" + getter: + q: ":SENS:INT?" + r: "{}" + setter: + q: ":SENS:INT {}" + # A GS200 with the /MON (monitoring) option + device 2: + eom: + GPIB INSTR: + q: "\n" + r: "\n" + error: ERROR + dialogues: + - q: "*IDN?" + r: "QCoDeS Yokogawa Mock,GS200,xxxxxxxx,MOCKFW" + - q: "*OPT?" + r: "/MON" + # Same status register and error responses as device 1 + - *stb + - *esr + - *stat_even + - *stat_cond + - *syst_err + - q: ":MEAS?" + r: "+1.23450E-03" + properties: *gs200_properties resources: GPIB::1::INSTR: device: device 1 + GPIB::2::INSTR: + device: device 2 diff --git a/src/qcodes/instrument_drivers/yokogawa/Yokogawa_GS200.py b/src/qcodes/instrument_drivers/yokogawa/Yokogawa_GS200.py index 5c4f309b06ac..60150ebc6b32 100644 --- a/src/qcodes/instrument_drivers/yokogawa/Yokogawa_GS200.py +++ b/src/qcodes/instrument_drivers/yokogawa/Yokogawa_GS200.py @@ -219,17 +219,20 @@ def __init__( get_parser=_float_round, ) """Parameter NPLC""" - self.delay: Parameter[int, Self] = self.add_parameter( + # The instrument takes and returns the delay in seconds with a + # resolution of 1 ms, from 0 to 999999 ms (GS200 User's Manual + # IM GS210-01EN, p. 13-15). + self.delay: Parameter[float, Self] = self.add_parameter( "delay", label="Measurement Delay", - unit="ms", - vals=Ints(0, 999999), + unit="s", + vals=MultiTypeAnd(Numbers(0, 999.999), PermissiveMultiples(1e-3)), set_cmd=":SENS:DEL {}", - set_parser=int, + set_parser=float, get_cmd=":SENS:DEL?", - get_parser=_float_round, + get_parser=float, ) - """Parameter delay""" + """Measurement delay in s, with a resolution of 1 ms""" self.trigger: Parameter[str, Self] = self.add_parameter( "trigger", label="Trigger Source", @@ -309,7 +312,7 @@ def update_measurement_enabled( self._unit = unit if self._unit == "VOLT": self.measure.label = "Source Current" - self.measure.unit = "I" + self.measure.unit = "A" else: self.measure.label = "Source Voltage" self.measure.unit = "V" @@ -371,7 +374,7 @@ def __init__( ) """Parameter trigger""" - self.save: Parameter = self.add_parameter( + self.save: Parameter[str, Self] = self.add_parameter( "save", set_cmd=":PROG:SAVE '{}'", docstring="save the program to the system memory (.csv file)", @@ -394,15 +397,29 @@ def __init__( val_mapping={"OFF": 0, "ON": 1}, ) """Parameter repeat""" - self.count: Parameter = self.add_parameter( + self.count: Parameter[int | Literal["MIN", "MAX"], Self] = self.add_parameter( "count", label="step of the current program", get_cmd=":PROG:COUN?", set_cmd=":PROG:COUN {}", get_parser=int, vals=MultiTypeOr(Ints(1, 10000), Enum("MIN", "MAX")), + docstring=( + "The step at which the program begins execution. Besides an " + "integer, this can be set to 'MIN' (step 1) or 'MAX' " + "(step 10000). Getting the parameter always returns an integer, " + "but until it is read again, the cached value is the string that " + "was set. The value is therefore annotated as " + "``int | Literal['MIN', 'MAX']``." + ), ) - """Parameter count""" + """ + The step at which the program begins execution. Besides an integer, this + can be set to "MIN" (step 1) or "MAX" (step 10000). Getting the parameter + always returns an integer, but until it is read again, the cached value + is the string that was set. The value is therefore annotated as + ``int | Literal["MIN", "MAX"]``. + """ self.add_function( "start", call_cmd=":PROG:EDIT:STAR", docstring="start program editing" @@ -478,7 +495,7 @@ def __init__( # instrument (in a previous session or via the frontpanel). self.source_mode() - self.voltage_range: Parameter = self.add_parameter( + self.voltage_range: Parameter[float, Self] = self.add_parameter( "voltage_range", label="Voltage Source Range", unit="V", @@ -489,10 +506,10 @@ def __init__( ) """Parameter voltage_range""" - self.current_range: Parameter = self.add_parameter( + self.current_range: Parameter[float, Self] = self.add_parameter( "current_range", label="Current Source Range", - unit="I", + unit="A", get_cmd=partial(self._get_range, "CURR"), set_cmd=partial(self._set_range, "CURR"), vals=Enum(1e-3, 10e-3, 100e-3, 200e-3), @@ -500,7 +517,7 @@ def __init__( ) """Parameter current_range""" - self.range: DelegateParameter = self.add_parameter( + self.range: DelegateParameter[float] = self.add_parameter( "range", parameter_class=DelegateParameter, source=None ) """Parameter range""" @@ -518,27 +535,27 @@ def __init__( ) """Parameter auto_range""" - self.voltage: Parameter = self.add_parameter( + self.voltage: Parameter[float, Self] = self.add_parameter( "voltage", label="Voltage", unit="V", - set_cmd=partial(self._get_set_output, "VOLT"), - get_cmd=partial(self._get_set_output, "VOLT"), + set_cmd=partial(self._set_output_level, "VOLT"), + get_cmd=partial(self._get_output_level, "VOLT"), snapshot_exclude=self.source_mode() == "CURR", ) """Parameter voltage""" - self.current: Parameter = self.add_parameter( + self.current: Parameter[float, Self] = self.add_parameter( "current", label="Current", - unit="I", - set_cmd=partial(self._get_set_output, "CURR"), - get_cmd=partial(self._get_set_output, "CURR"), + unit="A", + set_cmd=partial(self._set_output_level, "CURR"), + get_cmd=partial(self._get_output_level, "CURR"), snapshot_exclude=self.source_mode() == "VOLT", ) """Parameter current""" - self.output_level: DelegateParameter = self.add_parameter( + self.output_level: DelegateParameter[float] = self.add_parameter( "output_level", parameter_class=DelegateParameter, source=None ) """Parameter output_level""" @@ -575,7 +592,7 @@ def __init__( self.current_limit: Parameter[float, Self] = self.add_parameter( "current_limit", label="Current Protection Limit", - unit="I", + unit="A", vals=Numbers(1e-3, 200e-3), get_cmd=":SOUR:PROT:CURR?", set_cmd=":SOUR:PROT:CURR {:.3f}", @@ -660,7 +677,7 @@ def __init__( ) """returns the oldest unread error message from the event log and removes it from the log.""" - self.status_byte: Parameter = self.add_parameter( + self.status_byte: Parameter[StatusByte, Self] = self.add_parameter( "status_byte", get_cmd="*STB?", get_parser=lambda x: StatusByte(int(x)), @@ -668,27 +685,33 @@ def __init__( ) """Query the instrument status byte.""" - self.standard_event_register: Parameter = self.add_parameter( - "standard_event_register", - get_cmd="*ESR?", - get_parser=lambda x: StandardEventRegister(int(x)), - label="Standard Event Register", + self.standard_event_register: Parameter[StandardEventRegister, Self] = ( + self.add_parameter( + "standard_event_register", + get_cmd="*ESR?", + get_parser=lambda x: StandardEventRegister(int(x)), + label="Standard Event Register", + ) ) """Query the instrument standard event register.""" - self.extended_event_register: Parameter = self.add_parameter( - "extended_event_register", - get_cmd=":STAT:EVEN?", - get_parser=lambda x: ExtendedEventRegister(int(x)), - label="Extended Event Register", + self.extended_event_register: Parameter[ExtendedEventRegister, Self] = ( + self.add_parameter( + "extended_event_register", + get_cmd=":STAT:EVEN?", + get_parser=lambda x: ExtendedEventRegister(int(x)), + label="Extended Event Register", + ) ) """Query the instrument extended event register.""" - self.condition_register: Parameter = self.add_parameter( - "condition_register", - get_cmd=":STAT:COND?", - get_parser=lambda x: ConditionRegister(int(x)), - label="Condition Register", + self.condition_register: Parameter[ConditionRegister, Self] = ( + self.add_parameter( + "condition_register", + get_cmd=":STAT:COND?", + get_parser=lambda x: ConditionRegister(int(x)), + label="Condition Register", + ) ) """Query the instrument condition register.""" @@ -724,7 +747,7 @@ def __init__( "ramp_rate", ManualParameter, label="Ramp Rate", - unit="V/s", + unit="V/s" if self.source_mode() == "VOLT" else "A/s", vals=Numbers(1e-3 / 3600, float("inf")), initial_value=10e-3 if self.source_mode() == "VOLT" else 100e-6, ) @@ -734,12 +757,18 @@ def __init__( "ramp_step", ManualParameter, label="Ramp step", - unit="V", + unit="V" if self.source_mode() == "VOLT" else "A", vals=Numbers(0, float("inf")), initial_value=0, ) """The ramp step when :attr:`ramp_mode` is set to ``"SOFTWARE"``. + As for :attr:`Parameter.step`, a step of 0 (the default) means that + no steps are taken: setting the output in ``"SOFTWARE"`` mode then + jumps to the new value. :meth:`ramp_voltage` and :meth:`ramp_current` + with ``ramp_mode="SOFTWARE"`` require a positive step and raise a + ``ValueError`` otherwise. + When :attr:`ramp_mode` is ``"HARDWARE"``, defines the output delta above which a ramp is used. If the delta is below this value, the output is "jumped". @@ -788,6 +817,18 @@ def _parse_step(self, step: float | None) -> float: else: return self.ramp_step() + @staticmethod + def _check_software_ramp_step( + step: float, ramp_mode: Literal["HARDWARE", "SOFTWARE"] + ) -> None: + # A step of 0 disables stepping, which would turn an explicitly + # requested software ramp into a jump. + if ramp_mode == "SOFTWARE" and step <= 0: + raise ValueError( + "A software ramp requires a positive ramp step. Set ramp_step " + "to a positive value." + ) + def ramp_voltage( self, ramp_to: float, @@ -804,16 +845,19 @@ def ramp_voltage( delay: The time between finishing one step and starting another in seconds. Deprecated. ramp_mode: Use hardware or software ramps. See :attr:`ramp_mode`. + A software ramp requires a positive :attr:`ramp_step`. """ step = self._parse_step(step) rate = self._parse_delay(delay, step) self._assert_mode("VOLT") + self._check_software_ramp_step(step, ramp_mode) with ( self.ramp_step.set_to(step), self.ramp_rate.set_to(rate), - self.ramp_mode.set_to(ramp_mode), + # A software ramp temporarily switches ramp_mode to "JUMP". + self.ramp_mode.set_to(ramp_mode, allow_changes=True), self.ramp_blocking.set_to(True), ): self._ramp_source(ramp_to) @@ -830,20 +874,23 @@ def ramp_current( Args: ramp_to: The ramp target in Ampere - step: The ramp steps in Volt. Deprecated. + step: The ramp steps in Ampere. Deprecated. delay: The time between finishing one step and starting another in seconds. Deprecated. ramp_mode: Use hardware or software ramps. See :attr:`ramp_mode`. + A software ramp requires a positive :attr:`ramp_step`. """ step = self._parse_step(step) rate = self._parse_delay(delay, step) self._assert_mode("CURR") + self._check_software_ramp_step(step, ramp_mode) with ( self.ramp_step.set_to(step), self.ramp_rate.set_to(rate), - self.ramp_mode.set_to(ramp_mode), + # A software ramp temporarily switches ramp_mode to "JUMP". + self.ramp_mode.set_to(ramp_mode, allow_changes=True), self.ramp_blocking.set_to(True), ): self._ramp_source(ramp_to) @@ -920,6 +967,9 @@ def _ramp_source(self, ramp_to: float) -> None: # Sleep between 2 and 100 ms before checking again. time.sleep(max(min(slope_time / 10, 100e-3), 2e-3)) case "SOFTWARE": + # Check the target before changing the output, so that an + # out-of-range target does not leave the output partway. + self._validate_output_level(ramp_to) saved_step = self.output_level.step saved_inter_delay = self.output_level.inter_delay @@ -936,28 +986,55 @@ def _ramp_source(self, ramp_to: float) -> None: case _: raise ValueError(f"Unknown ramp mode: {self.ramp_mode()}") - def _get_set_output( - self, mode: ModeType, output_level: float | None = None - ) -> float | None: + def _get_output_level(self, mode: ModeType) -> float: """ - Get or set the output level. + Get the output level. Args: - mode: "CURR" or "VOLT" - output_level: If missing, we assume that we are getting the - current level. Else we are setting it + mode: "CURR" or "VOLT". Raises a ValueError if the instrument + is in the other source mode. """ self._assert_mode(mode) - if output_level is not None: - self._ramp_source(output_level) - return None return float(self.ask(":SOUR:LEV?")) + def _set_output_level(self, mode: ModeType, output_level: float) -> None: + """ + Set the output level according to :attr:`ramp_mode`. + + Args: + mode: "CURR" or "VOLT". Raises a ValueError if the instrument + is in the other source mode. + output_level: The output level in Volt or Ampere. + + """ + self._assert_mode(mode) + self._ramp_source(output_level) + def _set_output(self, output_level: float) -> None: """ Set the output of the instrument. + Args: + output_level: output level in Volt or Ampere, depending + on the current mode. + + """ + self._validate_output_level(output_level) + + if self.auto_range(): + auto_str = ":AUTO" + else: + auto_str = "" + cmd_str = f":SOUR:LEV{auto_str} {output_level:.5e}" + self.write(cmd_str) + + def _validate_output_level(self, output_level: float) -> None: + """ + Raise a ValueError if the output level is outside of the generated + output range of the present source range, or of the largest range if + auto range is enabled. + Args: output_level: output level in Volt or Ampere, depending on the current mode. @@ -1005,13 +1082,6 @@ def _set_output(self, output_level: float) -> None: f" [-{self_range:.3}, {self_range:.3}]" ) - if auto_enabled: - auto_str = ":AUTO" - else: - auto_str = "" - cmd_str = f":SOUR:LEV{auto_str} {output_level:.5e}" - self.write(cmd_str) - def _get_output_limit(self, source_range: float) -> float: """Return the generated output limit for a nominal source range. diff --git a/tests/drivers/test_yokogawa_gs200.py b/tests/drivers/test_yokogawa_gs200.py index 89f0e65a76bd..d3c3439d72f8 100644 --- a/tests/drivers/test_yokogawa_gs200.py +++ b/tests/drivers/test_yokogawa_gs200.py @@ -1,11 +1,19 @@ from __future__ import annotations import math +from functools import partial from typing import TYPE_CHECKING, Literal import pytest -from qcodes.instrument_drivers.yokogawa import YokogawaGS200 +from qcodes.instrument_drivers.yokogawa import YokogawaGS200, YokogawaGS200Exception +from qcodes.instrument_drivers.yokogawa.Yokogawa_GS200 import ( + ConditionRegister, + ExtendedEventRegister, + StandardEventRegister, + StatusByte, +) +from qcodes.utils import QCoDeSDeprecationWarning if TYPE_CHECKING: from collections.abc import Iterator @@ -36,6 +44,17 @@ def _make_gs200() -> Iterator[YokogawaGS200]: gs200.close() +@pytest.fixture(scope="function", name="gs200_mon") +def _make_gs200_with_monitor() -> Iterator[YokogawaGS200]: + """A GS200 with the /MON (monitoring) option.""" + gs200 = YokogawaGS200( + "GS200_mon", address="GPIB0::2::INSTR", pyvisa_sim_file="Yokogawa_GS200.yaml" + ) + yield gs200 + + gs200.close() + + def test_basic_init(gs200: YokogawaGS200) -> None: idn = gs200.get_idn() assert idn["vendor"] == "QCoDeS Yokogawa Mock" @@ -182,6 +201,31 @@ def test_software_ramp_within_generated_range( assert gs200.ramp_mode() == "SOFTWARE" +@pytest.mark.parametrize("use_ramp_voltage", (False, True)) +def test_software_ramp_rejects_target_before_stepping( + gs200: YokogawaGS200, mocker: MockerFixture, use_ramp_voltage: bool +) -> None: + gs200.voltage_range(10) + gs200.voltage(1) + gs200.ramp_step(1) + gs200.ramp_rate(1000) + gs200.ramp_mode("SOFTWARE") + write = mocker.spy(gs200, "write") + set_target = ( + partial(gs200.ramp_voltage, ramp_mode="SOFTWARE") + if use_ramp_voltage + else gs200.voltage + ) + + with pytest.raises(ValueError, match="Desired output level not in range"): + set_target(13) + + write.assert_not_called() + assert gs200.voltage() == 1 + assert gs200.output_level.step is None + assert gs200.output_level.inter_delay == 0 + + @pytest.mark.parametrize("target", (12.0, -12.0, 12.1, -12.1)) def test_output_limit_uses_refreshed_range( gs200: YokogawaGS200, mocker: MockerFixture, target: float @@ -218,8 +262,462 @@ def test_nominal_ranges_and_protection_limits_unchanged( write.assert_not_called() +@pytest.mark.parametrize("mode", ("VOLT", "CURR")) +def test_range_and_output_level_are_floats( + gs200: YokogawaGS200, mode: Literal["VOLT", "CURR"] +) -> None: + gs200.source_mode(mode) + if mode == "VOLT": + gs200.voltage_range(1) + gs200.voltage(0.5) + source_range, level = gs200.voltage_range, gs200.voltage + else: + gs200.current_range(10e-3) + gs200.current(5e-3) + source_range, level = gs200.current_range, gs200.current + + for parameter in (source_range, gs200.range, level, gs200.output_level): + value = parameter.get() + assert type(value) is float + + assert source_range.get() == gs200.range.get() + assert level.get() == gs200.output_level.get() + + +@pytest.mark.parametrize("fixture", ("gs200", "gs200_mon")) +def test_status_registers_return_flags( + request: pytest.FixtureRequest, fixture: str +) -> None: + gs200: YokogawaGS200 = request.getfixturevalue(fixture) + status_byte = gs200.status_byte() + assert isinstance(status_byte, StatusByte) + assert status_byte == StatusByte.RQS | StatusByte.EAV + + standard_event_register = gs200.standard_event_register() + assert isinstance(standard_event_register, StandardEventRegister) + assert standard_event_register == StandardEventRegister.CME + + extended_event_register = gs200.extended_event_register() + assert isinstance(extended_event_register, ExtendedEventRegister) + assert ( + extended_event_register == ExtendedEventRegister.EOP | ExtendedEventRegister.SCG + ) + + condition_register = gs200.condition_register() + assert isinstance(condition_register, ConditionRegister) + assert condition_register == ConditionRegister.RFP + + +@pytest.mark.parametrize("keyword,step", (("MIN", 1), ("MAX", 10000))) +def test_program_count_accepts_keywords( + gs200: YokogawaGS200, + mocker: MockerFixture, + keyword: Literal["MIN", "MAX"], + step: int, +) -> None: + write = mocker.spy(gs200, "write") + + gs200.program.count(keyword) + + write.assert_called_once_with(f":PROG:COUN {keyword}") + # The cache holds the keyword until the parameter is read again. + assert gs200.program.count.cache.get(get_if_invalid=False) == keyword + + # The instrument converts the keyword to step 1 or 10000 (GS200 User's + # Manual IM GS210-01EN, p. 13-14), but the simulator stores it verbatim, + # so answer the query as the instrument would. + ask_raw = mocker.patch.object(gs200, "ask_raw", return_value=str(step)) + + value = gs200.program.count.get() + + ask_raw.assert_called_once_with(":PROG:COUN?") + assert type(value) is int + assert value == step + assert gs200.program.count.cache.get(get_if_invalid=False) == step + + +def test_program_count_returns_int(gs200: YokogawaGS200) -> None: + gs200.program.count(3) + value = gs200.program.count.get() + assert type(value) is int + assert value == 3 + + +def test_program_save_sends_file_name( + gs200: YokogawaGS200, mocker: MockerFixture +) -> None: + write = mocker.patch.object(gs200, "write") + + gs200.program.save("test1.csv") + + write.assert_called_once_with(":PROG:SAVE 'test1.csv'") + assert gs200.program.save() == "test1.csv" + + +def test_current_parameters_use_ampere(gs200: YokogawaGS200) -> None: + assert gs200.current.unit == "A" + assert gs200.current_range.unit == "A" + assert gs200.current_limit.unit == "A" + + +def test_ramp_units_follow_source_mode_at_init(mocker: MockerFixture) -> None: + # The simulator always starts in VOLT mode, so pretend that the + # instrument was left in CURR mode before connecting. + original_ask_raw = YokogawaGS200.ask_raw + + def ask_raw(self: YokogawaGS200, cmd: str) -> str: + if cmd == ":SOUR:FUNC?": + return "CURR" + return original_ask_raw(self, cmd) + + mocker.patch.object(YokogawaGS200, "ask_raw", ask_raw) + gs200 = YokogawaGS200( + "GS200_curr", address="GPIB0::1::INSTR", pyvisa_sim_file="Yokogawa_GS200.yaml" + ) + try: + assert gs200.source_mode() == "CURR" + assert gs200.ramp_rate.unit == "A/s" + assert gs200.ramp_step.unit == "A" + finally: + gs200.close() + + def test_hardware_ramp_still_requires_output_enabled(gs200: YokogawaGS200) -> None: gs200.voltage_range(10) gs200.ramp_mode("HARDWARE") with pytest.raises(RuntimeError, match="Need to enable output"): gs200.voltage(12) + + +def test_cannot_switch_source_mode_with_output_on(gs200: YokogawaGS200) -> None: + gs200.output("on") + with pytest.raises(YokogawaGS200Exception, match="Cannot switch mode"): + gs200.source_mode("CURR") + assert gs200.source_mode() == "VOLT" + + +def test_program_execution_control(gs200: YokogawaGS200, mocker: MockerFixture) -> None: + write = mocker.patch.object(gs200, "write") + + gs200.program.hold() + gs200.program.pause() + gs200.program.cont() + + assert [call.args[0] for call in write.call_args_list] == [ + ":PROG:HOLD", + ":PROG:PAUS", + ":PROG:CONT", + ] + + +def test_ramp_voltage(gs200: YokogawaGS200, mocker: MockerFixture) -> None: + gs200.voltage_range(10) + gs200.voltage(1) + gs200.ramp_step(0.5) + gs200.ramp_rate(1000) + write = mocker.spy(gs200, "write") + + gs200.ramp_voltage(2, ramp_mode="SOFTWARE") + + assert [call.args[0] for call in write.call_args_list] == [ + f":SOUR:LEV {voltage:.5e}" for voltage in (1.5, 2) + ] + assert gs200.voltage() == 2 + # The ramp settings are only changed for the duration of the ramp. + assert gs200.ramp_mode() == "JUMP" + assert gs200.ramp_step() == 0.5 + assert gs200.ramp_rate() == 1000 + + +def test_ramp_current(gs200: YokogawaGS200, mocker: MockerFixture) -> None: + gs200.source_mode("CURR") + gs200.current_range(10e-3) + gs200.current(1e-3) + gs200.ramp_step(0.5e-3) + gs200.ramp_rate(1) + write = mocker.spy(gs200, "write") + + gs200.ramp_current(2e-3, ramp_mode="SOFTWARE") + + assert [call.args[0] for call in write.call_args_list] == [ + f":SOUR:LEV {current:.5e}" for current in (1.5e-3, 2e-3) + ] + assert gs200.current() == pytest.approx(2e-3) + + +@pytest.mark.parametrize("mode", ("VOLT", "CURR")) +def test_software_ramp_requires_positive_step( + gs200: YokogawaGS200, mocker: MockerFixture, mode: Literal["VOLT", "CURR"] +) -> None: + gs200.source_mode(mode) + assert gs200.ramp_step() == 0 + ramp = gs200.ramp_voltage if mode == "VOLT" else gs200.ramp_current + write = mocker.spy(gs200, "write") + + with pytest.raises(ValueError, match="requires a positive ramp step"): + ramp(1e-3, ramp_mode="SOFTWARE") + + write.assert_not_called() + assert gs200.ramp_mode() == "JUMP" + + +def test_software_ramp_mode_with_zero_step_jumps( + gs200: YokogawaGS200, mocker: MockerFixture +) -> None: + # As for Parameter.step, a ramp_step of 0 means no steps. + gs200.voltage_range(10) + gs200.ramp_mode("SOFTWARE") + write = mocker.spy(gs200, "write") + + gs200.voltage(5) + + write.assert_called_once_with(f":SOUR:LEV {5:.5e}") + + +def test_ramp_requires_matching_source_mode(gs200: YokogawaGS200) -> None: + with pytest.raises(ValueError, match="Cannot get/set CURR settings"): + gs200.ramp_current(1e-3) + gs200.source_mode("CURR") + with pytest.raises(ValueError, match="Cannot get/set VOLT settings"): + gs200.ramp_voltage(1) + + +def test_ramp_deprecated_step_and_delay( + gs200: YokogawaGS200, mocker: MockerFixture +) -> None: + gs200.voltage_range(10) + gs200.voltage(1) + write = mocker.spy(gs200, "write") + + with pytest.warns(QCoDeSDeprecationWarning) as record: + gs200.ramp_voltage(2, step=0.5, delay=1e-3, ramp_mode="SOFTWARE") + + messages = [str(warning.message) for warning in record] + assert any("step parameter is deprecated" in msg for msg in messages) + assert any("delay parameter is deprecated" in msg for msg in messages) + assert [call.args[0] for call in write.call_args_list] == [ + f":SOUR:LEV {voltage:.5e}" for voltage in (1.5, 2) + ] + # step and delay only apply to this ramp + assert gs200.ramp_step() == 0 + assert gs200.ramp_rate() == 10e-3 + + +@pytest.fixture(name="gs200_hw_ramp") +def _make_gs200_for_hardware_ramp( + gs200: YokogawaGS200, +) -> YokogawaGS200: + gs200.voltage_range(10) + gs200.voltage(1) + gs200.output("on") + gs200.ramp_mode("HARDWARE") + return gs200 + + +def test_hardware_ramp_skips_zero_delta( + gs200_hw_ramp: YokogawaGS200, mocker: MockerFixture +) -> None: + write = mocker.spy(gs200_hw_ramp, "write") + + gs200_hw_ramp.voltage(1) + + write.assert_not_called() + + +def test_hardware_ramp_jumps_below_ramp_step( + gs200_hw_ramp: YokogawaGS200, mocker: MockerFixture +) -> None: + gs200_hw_ramp.ramp_step(0.5) + write = mocker.spy(gs200_hw_ramp, "write") + + gs200_hw_ramp.voltage(1.2) + + write.assert_called_once_with(f":SOUR:LEV {1.2:.5e}") + + +def test_hardware_ramp_clips_slope_time( + gs200_hw_ramp: YokogawaGS200, + mocker: MockerFixture, + caplog: pytest.LogCaptureFixture, +) -> None: + gs200_hw_ramp.ramp_blocking(False) + gs200_hw_ramp.ramp_rate(1e-6) + # The simulator does not know the program commands. + write = mocker.patch.object(gs200_hw_ramp, "write") + + with caplog.at_level("INFO"): + gs200_hw_ramp.voltage(2) + + assert "Slope time > 3600s. Clipping." in caplog.text + (command,) = write.call_args.args + assert ":PROG:SLOP 3.600000E+03" in command + assert ":PROG:INT 3.600000E+03" in command + + +def test_hardware_ramp_blocks_until_end_of_program( + gs200_hw_ramp: YokogawaGS200, + mocker: MockerFixture, + caplog: pytest.LogCaptureFixture, +) -> None: + gs200_hw_ramp.ramp_rate(20) + write = mocker.patch.object(gs200_hw_ramp, "write") + mocker.patch.object( + gs200_hw_ramp.extended_event_register, + "get", + side_effect=[ExtendedEventRegister(0), ExtendedEventRegister.EOP], + ) + status_byte = mocker.patch.object( + gs200_hw_ramp.status_byte, "get", return_value=StatusByte(0) + ) + + with caplog.at_level("INFO"): + gs200_hw_ramp.voltage(2) + + assert "Interval time < 0.1s. Clipping." in caplog.text + assert write.call_args.args[0] == ( + "*CLS;" + ":PROG:REP 0;" + ":PROG:SLOP 5.000000E-02;" + ":PROG:INT 1.000000E-01;" + ":PROG:EDIT:STAR;" + ":SOUR:LEV 2.000000E+00;" + ":PROG:EDIT:END;" + ":PROG:RUN" + ) + status_byte.assert_called_once() + + +def test_hardware_ramp_raises_on_instrument_error( + gs200_hw_ramp: YokogawaGS200, mocker: MockerFixture +) -> None: + mocker.patch.object(gs200_hw_ramp, "write") + mocker.patch.object( + gs200_hw_ramp.extended_event_register, + "get", + return_value=ExtendedEventRegister(0), + ) + + # The simulated status byte reports an error (EAV) + with pytest.raises(RuntimeError, match="Ramp failed with errors: -222"): + gs200_hw_ramp.voltage(2) + + +def test_monitor_only_with_mon_option( + gs200: YokogawaGS200, gs200_mon: YokogawaGS200 +) -> None: + assert not gs200.measure.present + assert "measure" not in gs200.measure.parameters + assert "trigger" not in gs200.program.parameters + + assert gs200_mon.measure.present + assert "measure" in gs200_mon.measure.parameters + assert "trigger" in gs200_mon.program.parameters + + +def test_monitor_label_and_unit_follow_source_mode( + gs200_mon: YokogawaGS200, +) -> None: + measure = gs200_mon.measure.measure + + gs200_mon.source_mode("CURR") + assert measure.label == "Source Voltage" + assert measure.unit == "V" + + gs200_mon.source_mode("VOLT") + assert measure.label == "Source Current" + assert measure.unit == "A" + + +def test_monitor_measure(gs200_mon: YokogawaGS200) -> None: + monitor = gs200_mon.measure + + with pytest.raises(YokogawaGS200Exception, match="not initialized"): + monitor.measure() + + gs200_mon.source_mode("VOLT") + with pytest.raises(YokogawaGS200Exception, match="Output is off"): + monitor.measure() + + gs200_mon.output("on") + with pytest.raises(YokogawaGS200Exception, match="Measurements are disabled"): + monitor.measure() + + monitor.enabled("on") + assert monitor.enabled() == "on" + assert monitor.measure() == 1.2345e-3 + + gs200_mon.output("off") + with pytest.raises(YokogawaGS200Exception, match="Output is off"): + monitor.measure() + gs200_mon.output("on") + + monitor.enabled("off") + assert monitor.enabled() == "off" + with pytest.raises(YokogawaGS200Exception, match="Measurements are disabled"): + monitor.measure() + + +def test_monitor_measure_unavailable_in_low_voltage_range_and_auto_range( + gs200_mon: YokogawaGS200, +) -> None: + monitor = gs200_mon.measure + gs200_mon.source_mode("VOLT") + gs200_mon.output("on") + + gs200_mon.voltage_range(100e-3) + monitor.enabled("on") + with pytest.raises(YokogawaGS200Exception, match="will not work"): + monitor.measure() + + gs200_mon.voltage_range(10) + monitor.enabled("on") + gs200_mon.auto_range(True) + with pytest.raises(YokogawaGS200Exception, match="will not work"): + monitor.measure() + + gs200_mon.auto_range(False) + # Enabling auto range turned the measurement off + with pytest.raises(YokogawaGS200Exception, match="Measurements are disabled"): + monitor.measure() + + +def test_monitor_settings(gs200_mon: YokogawaGS200, mocker: MockerFixture) -> None: + monitor = gs200_mon.measure + assert monitor.NPLC() == 1 + monitor.NPLC(10) + assert monitor.NPLC() == 10 + + write = mocker.spy(gs200_mon, "write") + monitor.trigger("TIMER") + write.assert_called_once_with(":SENS:TRIG TIM") + assert monitor.trigger() == "TIM" + + monitor.interval(2.5) + assert monitor.interval() == 2.5 + + +def test_monitor_delay_in_seconds( + gs200_mon: YokogawaGS200, mocker: MockerFixture +) -> None: + # The instrument takes and returns the delay in seconds with a resolution + # of 1 ms (GS200 User's Manual IM GS210-01EN, p. 13-15). + monitor = gs200_mon.measure + assert monitor.delay.unit == "s" + assert monitor.delay() == 0 + + write = mocker.spy(gs200_mon, "write") + monitor.delay(0.5) + write.assert_called_once_with(":SENS:DEL 0.5") + assert monitor.delay() == 0.5 + + # e.g. set to 1.234 s on the front panel + gs200_mon.write(":SENS:DEL +1234E-3") + value = monitor.delay() + assert type(value) is float + assert value == 1.234 + + write.reset_mock() + for invalid in (-1e-3, 1000.0, 0.5005): + with pytest.raises(ValueError): + monitor.delay(invalid) + write.assert_not_called()