# # 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 time import os import json import numpy as np import pandas as pd from pymeasure.instruments import Instrument, SCPIUnknownMixin from pymeasure.instruments.validators import (strict_discrete_set, truncated_discrete_set, strict_range) import logging log = logging.getLogger(__name__) log.addHandler(logging.NullHandler()) ###### # MAIN ###### class Agilent4156(SCPIUnknownMixin, Instrument): """ Represents the Agilent 4155/4156 Semiconductor Parameter Analyzer and provides a high-level interface for taking current-voltage (I-V) measurements. .. code-block:: python from pymeasure.instruments.agilent import Agilent4156 # explicitly define r/w terminations; set sufficiently large timeout or None. smu = Agilent4156("GPIB0::25", read_termination = '\\n', write_termination = '\\n', timeout=None) # reset the instrument smu.reset() # define configuration file for instrument and load config smu.configure("configuration_file.json") # save data variables, some or all of which are defined in the json config file. smu.save(['VC', 'IC', 'VB', 'IB']) # take measurements status = smu.measure() # measured data is a pandas dataframe and can be exported to csv. data = smu.get_data(path='./t1.csv') The JSON file is an ascii text configuration file that defines the settings of each channel on the instrument. The JSON file is used to configure the instrument using the convenience function :meth:`~.Agilent4156.configure` as shown in the example above. For example, the instrument setup for a bipolar transistor measurement is shown below. .. code-block:: json { "SMU1": { "voltage_name" : "VC", "current_name" : "IC", "channel_function" : "VAR1", "channel_mode" : "V", "series_resistance" : "0OHM" }, "SMU2": { "voltage_name" : "VB", "current_name" : "IB", "channel_function" : "VAR2", "channel_mode" : "I", "series_resistance" : "0OHM" }, "SMU3": { "voltage_name" : "VE", "current_name" : "IE", "channel_function" : "CONS", "channel_mode" : "V", "constant_value" : 0, "compliance" : 0.1 }, "SMU4": { "voltage_name" : "VS", "current_name" : "IS", "channel_function" : "CONS", "channel_mode" : "V", "constant_value" : 0, "compliance" : 0.1 }, "VAR1": { "start" : 1, "stop" : 2, "step" : 0.1, "spacing" : "LINEAR", "compliance" : 0.1 }, "VAR2": { "start" : 0, "step" : 10e-6, "points" : 3, "compliance" : 2 } } """ def __init__(self, adapter, name="Agilent 4155/4156 Semiconductor Parameter Analyzer", **kwargs): super().__init__( adapter, name, **kwargs ) self.smu1 = SMU(self.adapter, 'SMU1', **kwargs) self.smu2 = SMU(self.adapter, 'SMU2', **kwargs) self.smu3 = SMU(self.adapter, 'SMU3', **kwargs) self.smu4 = SMU(self.adapter, 'SMU4', **kwargs) self.vmu1 = VMU(self.adapter, 'VMU1', **kwargs) self.vmu2 = VMU(self.adapter, 'VMU2', **kwargs) self.vsu1 = VSU(self.adapter, 'VSU1', **kwargs) self.vsu2 = VSU(self.adapter, 'VSU2', **kwargs) self.var1 = VAR1(self.adapter, **kwargs) self.var2 = VAR2(self.adapter, **kwargs) self.vard = VARD(self.adapter, **kwargs) analyzer_mode = Instrument.control( ":PAGE:CHAN:MODE?", ":PAGE:CHAN:MODE %s", """ A string property that controls the instrument operating mode. - Values: :code:`SWEEP`, :code:`SAMPLING` .. code-block:: python smu.analyzer_mode = "SWEEP" """, validator=strict_discrete_set, values={'SWEEP': 'SWE', 'SAMPLING': 'SAMP'}, map_values=True, check_set_errors=True, check_get_errors=True ) integration_time = Instrument.control( ":PAGE:MEAS:MSET:ITIM?", ":PAGE:MEAS:MSET:ITIM %s", """ A string property that controls the integration time. - Values: :code:`SHORT`, :code:`MEDIUM`, :code:`LONG` .. code-block:: python instr.integration_time = "MEDIUM" """, validator=strict_discrete_set, values={'SHORT': 'SHOR', 'MEDIUM': 'MED', 'LONG': 'LONG'}, map_values=True, check_set_errors=True, check_get_errors=True ) delay_time = Instrument.control( ":PAGE:MEAS:DEL?", ":PAGE:MEAS:DEL %g", """ A floating point property that measurement delay time in seconds, which can take the values from 0 to 65s in 0.1s steps. .. code-block:: python instr.delay_time = 1 # delay time of 1-sec """, validator=truncated_discrete_set, values=np.arange(0, 65.1, 0.1), check_set_errors=True, check_get_errors=True ) hold_time = Instrument.control( ":PAGE:MEAS:HTIME?", ":PAGE:MEAS:HTIME %g", """ A floating point property that measurement hold time in seconds, which can take the values from 0 to 655s in 1s steps. .. code-block:: python instr.hold_time = 2 # hold time of 2-secs. """, validator=truncated_discrete_set, values=np.arange(0, 655, 1), check_set_errors=True, check_get_errors=True ) def stop(self): """Stops the ongoing measurement .. code-block:: python instr.stop() """ self.write(":PAGE:SCON:STOP") def measure(self, period="INF", points=100): """ Performs a single measurement and waits for completion in sweep mode. In sampling mode, the measurement period and number of points can be specified. :param period: Period of sampling measurement from 6E-6 to 1E11 seconds. Default setting is :code:`INF`. :param points: Number of samples to be measured, from 1 to 10001. Default setting is :code:`100`. .. code-block::python instr.measure() #for sweep measurement instr.measure(period=100, points=100) #for sampling measurement """ if self.analyzer_mode == "SWEEP": self.write(":PAGE:SCON:MEAS:SING; *OPC?") else: self.write(f":PAGE:MEAS:SAMP:PER {period}") self.write(f":PAGE:MEAS:SAMP:POIN {points}") self.write(":PAGE:SCON:MEAS:SING; *OPC?") def disable_all(self): """ Disables all channels in the instrument. .. code-block:: python instr.disable_all() """ self.smu1.disable time.sleep(0.1) self.smu2.disable time.sleep(0.1) self.smu3.disable time.sleep(0.1) self.smu4.disable time.sleep(0.1) self.vmu1.disable time.sleep(0.1) self.vmu2.disable time.sleep(0.1) def configure(self, config_file): """ Configure the channel setup and sweep using a JSON configuration file. (JSON is the `JavaScript Object Notation`_) .. _`JavaScript Object Notation`: https://www.json.org/ :param config_file: JSON file to configure instrument channels. .. code-block:: python instr.configure('config.json') """ self.disable_all() obj_dict = {'SMU1': self.smu1, 'SMU2': self.smu2, 'SMU3': self.smu3, 'SMU4': self.smu4, 'VMU1': self.vmu1, 'VMU2': self.vmu2, 'VSU1': self.vsu1, 'VSU2': self.vsu2, 'VAR1': self.var1, 'VAR2': self.var2, 'VARD': self.vard } with open(config_file) as stream: try: instr_settings = json.load(stream) except json.JSONDecodeError as e: print(e) # replace dict keys with Instrument objects new_settings_dict = {} for key, value in instr_settings.items(): new_settings_dict[obj_dict[key]] = value for obj, setup in new_settings_dict.items(): for setting, value in setup.items(): setattr(obj, setting, value) time.sleep(0.1) def save(self, trace_list): """ Save the voltage or current in the instrument display list :param trace_list: A list of channel variables whose measured data should be saved. A maximum of 8 variables are allowed. If only one variable is being saved, a string can be specified. .. code-block:: python instr.save(['IC', 'IB', 'VC', 'VB']) #for list of variables instr.save('IC') #for single variable """ self.write(":PAGE:DISP:MODE LIST") if isinstance(trace_list, list): if len(trace_list) > 8: raise RuntimeError('Maximum of 8 variables allowed') else: for name in trace_list: self.write(f":PAGE:DISP:LIST \'{name}\'") elif isinstance(trace_list, str): self.write(f":PAGE:DISP:LIST \'{trace_list}\'") else: raise TypeError( 'Must be a string if only one variable is saved, or else a list if' 'multiple variables are being saved.' ) def save_var(self, trace_list): """ Save the voltage or current in the instrument variable list. This is useful if one or two more variables need to be saved in addition to the 8 variables allowed by :meth:`~.Agilent4156.save`. :param trace_list: A list of channel variables whose measured data should be saved. A maximum of 2 variables are allowed. If only one variable is being saved, a string can be specified. .. code-block:: python instr.save_var(['VA', 'VB']) """ self.write(":PAGE:DISP:MODE LIST") if isinstance(trace_list, list): if len(trace_list) > 2: raise RuntimeError('Maximum of 2 variables allowed') else: for name in trace_list: self.write(f":PAGE:DISP:DVAR \'{name}\'") elif isinstance(trace_list, str): self.write(f":PAGE:DISP:DVAR \'{trace_list}\'") else: raise TypeError( 'Must be a string if only one variable is saved, or else a list if' 'multiple variables are being saved.' ) @property def data_variables(self): """ Get a string list of data variables for which measured data is available. This looks for all the variables saved by the :meth:`~.Agilent4156.save` and :meth:`~.Agilent4156.save_var` methods and returns it. This is useful for creation of dataframe headers. :returns: List .. code-block:: python header = instr.data_variables """ dlist = self.ask(":PAGE:DISP:LIST?").split(',') dvar = self.ask(":PAGE:DISP:DVAR?").split(',') varlist = dlist + dvar return list(filter(None, varlist)) def get_data(self, path=None): """ Get the measurement data from the instrument after completion. If the measurement period is set to :code:`INF` in the :meth:`~.Agilent4156.measure` method, then the measurement must be stopped using :meth:`~.Agilent4156.stop` before getting valid data. :param path: Path for optional data export to CSV. :returns: Pandas Dataframe .. code-block:: python df = instr.get_data(path='./datafolder/data1.csv') """ if int(self.ask('*OPC?')): header = self.data_variables self.write(":FORM:DATA ASC") # recursively get data for each variable for i, listvar in enumerate(header): data = self.values(f":DATA? \'{listvar}\'") time.sleep(0.01) if i == 0: lastdata = data else: data = np.column_stack((lastdata, data)) lastdata = data df = pd.DataFrame(data=data, columns=header, index=None) if path is not None: _, ext = os.path.splitext(path) if ext != ".csv": path = path + ".csv" df.to_csv(path, index=False) return df ########## # CHANNELS ########## class SMU(SCPIUnknownMixin, Instrument): def __init__(self, adapter, channel, **kwargs): super().__init__( adapter, "SMU of Agilent 4155/4156 Semiconductor Parameter Analyzer", **kwargs ) self.channel = channel.upper() @property def channel_mode(self): """ A string property that controls the SMU channel mode. - Values: :code:`V`, :code:`I` or :code:`COMM` VPULSE AND IPULSE are not yet supported. .. code-block:: python instr.smu1.channel_mode = "V" """ value = self.ask(f":PAGE:CHAN:{self.channel}:MODE?") self.check_errors() return value @channel_mode.setter def channel_mode(self, mode): validator = strict_discrete_set values = ["V", "I", "COMM"] value = validator(mode, values) self.write(f":PAGE:CHAN:{self.channel}:MODE {value}") self.check_errors() @property def channel_function(self): """ A string property that controls the SMU channel function. - Values: :code:`VAR1`, :code:`VAR2`, :code:`VARD` or :code:`CONS`. .. code-block:: python instr.smu1.channel_function = "VAR1" """ value = self.ask(f":PAGE:CHAN:{self.channel}:FUNC?") self.check_errors() return value @channel_function.setter def channel_function(self, function): validator = strict_discrete_set values = ["VAR1", "VAR2", "VARD", "CONS"] value = validator(function, values) self.write(f":PAGE:CHAN:{self.channel}:FUNC {value}") self.check_errors() @property def series_resistance(self): """ Controls the series resistance of SMU. - Values: :code:`0OHM`, :code:`10KOHM`, :code:`100KOHM`, or :code:`1MOHM` .. code-block:: python instr.smu1.series_resistance = "10KOHM" """ value = self.ask(f":PAGE:CHAN:{self.channel}:SRES?") self.check_errors() return value @series_resistance.setter def series_resistance(self, sres): validator = strict_discrete_set values = ["0OHM", "10KOHM", "100KOHM", "1MOHM"] value = validator(sres, values) self.write(f":PAGE:CHAN:{self.channel}:SRES {value}") self.check_errors() @property def disable(self): """ Deletes the settings of SMU. .. code-block:: python instr.smu1.disable() """ self.write(f":PAGE:CHAN:{self.channel}:DIS") self.check_errors() @property def constant_value(self): """ Set the constant source value of SMU. You use this command only if :meth:`~.SMU.channel_function` is :code:`CONS` and also :meth:`~.SMU.channel_mode` should not be :code:`COMM`. :param const_value: Voltage in (-200V, 200V) and current in (-1A, 1A). Voltage or current depends on if :meth:`~.SMU.channel_mode` is set to :code:`V` or :code:`I`. .. code-block:: python instr.smu1.constant_value = 1 """ if Agilent4156.analyzer_mode.fget(self) == "SWEEP": value = self.ask(f":PAGE:MEAS:CONS:{self.channel}?") else: value = self.ask(f":PAGE:MEAS:SAMP:CONS:{self.channel}?") self.check_errors() return value @constant_value.setter def constant_value(self, const_value): validator = strict_range values = self.__validate_cons() value = validator(const_value, values) if Agilent4156.analyzer_mode.fget(self) == 'SWEEP': self.write(f":PAGE:MEAS:CONS:{self.channel} {value}") else: self.write(":PAGE:MEAS:SAMP:CONS:{} {}".format( self.channel, value)) self.check_errors() @property def compliance(self): """ Sets the *constant* compliance value of SMU. If the SMU channel is setup as a variable (VAR1, VAR2, VARD) then compliance limits are set by the variable definition. - Value: Voltage in (-200V, 200V) and current in (-1A, 1A) based on :meth:`~.SMU.channel_mode`. .. code-block:: python instr.smu1.compliance = 0.1 """ if Agilent4156.analyzer_mode.fget(self) == "SWEEP": value = self.ask(f":PAGE:MEAS:CONS:{self.channel}:COMP?") else: value = self.ask( f":PAGE:MEAS:SAMP:CONS:{self.channel}:COMP?") self.check_errors() return value @compliance.setter def compliance(self, comp): validator = strict_range values = self.__validate_compl() value = validator(comp, values) if Agilent4156.analyzer_mode.fget(self) == 'SWEEP': self.write(":PAGE:MEAS:CONS:{}:COMP {}".format( self.channel, value)) else: self.write(":PAGE:MEAS:SAMP:CONS:{}:COMP {}".format( self.channel, value)) self.check_errors() @property def voltage_name(self): """ Define the voltage name of the channel. If input is greater than 6 characters long or starts with a number, the name is autocorrected and prepended with 'a'. Event is logged. .. code-block:: python instr.smu1.voltage_name = "Vbase" """ value = self.ask(f"PAGE:CHAN:{self.channel}:VNAME?") return value @voltage_name.setter def voltage_name(self, vname): value = check_current_voltage_name(vname) self.write(f":PAGE:CHAN:{self.channel}:VNAME \'{value}\'") @property def current_name(self): """ Define the current name of the channel. If input is greater than 6 characters long or starts with a number, the name is autocorrected and prepended with 'a'. Event is logged. .. code-block:: python instr.smu1.current_name = "Ibase" """ value = self.ask(f"PAGE:CHAN:{self.channel}:INAME?") return value @current_name.setter def current_name(self, iname): value = check_current_voltage_name(iname) self.write(f":PAGE:CHAN:{self.channel}:INAME \'{value}\'") def __validate_cons(self): """Validates the instrument settings for operation in constant mode. """ if not ((self.channel_mode != 'COMM') and ( self.channel_function == 'CONS')): raise ValueError( 'Cannot set constant SMU function when SMU mode is COMMON, ' 'or when SMU function is not CONSTANT.' ) else: values = valid_iv(self.channel_mode) return values def __validate_compl(self): """Validates the instrument compliance for operation in constant mode. """ if not ((self.channel_mode != 'COMM') and ( self.channel_function == 'CONS')): raise ValueError( 'Cannot set constant SMU parameters when SMU mode is COMMON, ' 'or when SMU function is not CONSTANT.' ) else: values = valid_compliance(self.channel_mode) return values class VMU(SCPIUnknownMixin, Instrument): def __init__(self, adapter, channel, **kwargs): super().__init__( adapter, "VMU of Agilent 4155/4156 Semiconductor Parameter Analyzer", **kwargs ) self.channel = channel.upper() @property def voltage_name(self): """ Define the voltage name of the VMU channel. If input is greater than 6 characters long or starts with a number, the name is autocorrected and prepended with 'a'. Event is logged. .. code-block:: python instr.vmu1.voltage_name = "Vanode" """ value = self.ask(f"PAGE:CHAN:{self.channel}:VNAME?") return value @voltage_name.setter def voltage_name(self, vname): value = check_current_voltage_name(vname) self.write(f":PAGE:CHAN:{self.channel}:VNAME \'{value}\'") @property def disable(self): """ Disables the settings of VMU. .. code-block:: python instr.vmu1.disable() """ self.write(f":PAGE:CHAN:{self.channel}:DIS") self.check_errors() @property def channel_mode(self): """ A string property that controls the VMU channel mode. - Values: :code:`V`, :code:`DVOL` """ value = self.ask(f":PAGE:CHAN:{self.channel}:MODE?") self.check_errors() return value @channel_mode.setter def channel_mode(self, mode): validator = strict_discrete_set values = ["V", "DVOL"] value = validator(mode, values) self.write(f":PAGE:CHAN:{self.channel}:MODE {value}") self.check_errors() class VSU(SCPIUnknownMixin, Instrument): def __init__(self, adapter, channel, **kwargs): super().__init__( adapter, "VSU of Agilent 4155/4156 Semiconductor Parameter Analyzer", **kwargs ) self.channel = channel.upper() @property def voltage_name(self): """ Define the voltage name of the VSU channel If input is greater than 6 characters long or starts with a number, the name is autocorrected and prepended with 'a'. Event is logged. .. code-block:: python instr.vsu1.voltage_name = "Ve" """ value = self.ask(f"PAGE:CHAN:{self.channel}:VNAME?") return value @voltage_name.setter def voltage_name(self, vname): value = check_current_voltage_name(vname) self.write(f":PAGE:CHAN:{self.channel}:VNAME \'{value}\'") @property def disable(self): """ Deletes the settings of VSU. .. code-block:: python instr.vsu1.disable() """ self.write(f":PAGE:CHAN:{self.channel}:DIS") self.check_errors() @property def channel_mode(self): """ Get channel mode of VSU.""" value = self.ask(f":PAGE:CHAN:{self.channel}:MODE?") self.check_errors() return value @property def constant_value(self): """ Sets the constant source value of VSU. .. code-block:: python instr.vsu1.constant_value = 0 """ if Agilent4156.analyzer_mode.fget(self) == "SWEEP": value = self.ask(f":PAGE:MEAS:CONS:{self.channel}?") else: value = self.ask(f":PAGE:MEAS:SAMP:CONS:{self.channel}?") self.check_errors() return value @constant_value.setter def constant_value(self, const_value): validator = strict_range values = [-200, 200] value = validator(const_value, values) if Agilent4156.analyzer_mode.fget(self) == 'SWEEP': self.write(f":PAGE:MEAS:CONS:{self.channel} {value}") else: self.write(":PAGE:MEAS:SAMP:CONS:{} {}".format( self.channel, value)) self.check_errors() @property def channel_function(self): """ A string property that controls the VSU channel function. - Value: :code:`VAR1`, :code:`VAR2`, :code:`VARD` or :code:`CONS`. """ value = self.ask(f":PAGE:CHAN:{self.channel}:FUNC?") self.check_errors() return value @channel_function.setter def channel_function(self, function): validator = strict_discrete_set values = ["VAR1", "VAR2", "VARD", "CONS"] value = validator(function, values) self.write(f":PAGE:CHAN:{self.channel}:FUNC {value}") self.check_errors() ################# # SWEEP VARIABLES ################# class VARX(SCPIUnknownMixin, Instrument): """ Base class to define sweep variable settings """ def __init__(self, adapter, var_name, **kwargs): super().__init__( adapter, "Methods to setup sweep variables", **kwargs ) self.var = var_name.upper() @property def channel_mode(self): channels = ['SMU1', 'SMU2', 'SMU3', 'SMU4', 'VSU1', 'VSU2'] for ch in channels: ch_func = self.ask(f":PAGE:CHAN:{ch}:FUNC?") if ch_func == self.var: ch_mode = self.ask(f":PAGE:CHAN:{ch}:MODE?") return ch_mode @property def start(self): """ Sets the sweep START value. .. code-block:: python instr.var1.start = 0 """ value = self.ask(f":PAGE:MEAS:{self.var}:STAR?") self.check_errors() return value @start.setter def start(self, value): validator = strict_range values = valid_iv(self.channel_mode) set_value = validator(value, values) self.write(f":PAGE:MEAS:{self.var}:STAR {set_value}") self.check_errors() @property def stop(self): """ Sets the sweep STOP value. .. code-block:: python instr.var1.stop = 3 """ value = self.ask(f":PAGE:MEAS:{self.var}:STOP?") self.check_errors() return value @stop.setter def stop(self, value): validator = strict_range values = valid_iv(self.channel_mode) set_value = validator(value, values) self.write(f":PAGE:MEAS:{self.var}:STOP {set_value}") self.check_errors() @property def step(self): """ Sets the sweep STEP value. .. code-block:: python instr.var1.step = 0.1 """ value = self.ask(f":PAGE:MEAS:{self.var}:STEP?") self.check_errors() return value @step.setter def step(self, value): validator = strict_range values = 2 * valid_iv(self.channel_mode) set_value = validator(value, values) self.write(f":PAGE:MEAS:{self.var}:STEP {set_value}") self.check_errors() @property def compliance(self): """ Sets the sweep COMPLIANCE value. .. code-block:: python instr.var1.compliance = 0.1 """ value = self.ask(":PAGE:MEAS:{}:COMP?") self.check_errors() return value @compliance.setter def compliance(self, value): validator = strict_range values = 2 * valid_compliance(self.channel_mode) set_value = validator(value, values) self.write(f":PAGE:MEAS:{self.var}:COMP {set_value}") self.check_errors() class VAR1(VARX): """ Class to handle all the specific definitions needed for VAR1. Most common methods are inherited from base class. """ def __init__(self, adapter, **kwargs): super().__init__( adapter, "VAR1", **kwargs ) spacing = Instrument.control( ":PAGE:MEAS:VAR1:SPAC?", ":PAGE:MEAS:VAR1:SPAC %s", """ Selects the sweep type of VAR1. - Values: :code:`LINEAR`, :code:`LOG10`, :code:`LOG25`, :code:`LOG50`. """, validator=strict_discrete_set, values={'LINEAR': 'LIN', 'LOG10': 'L10', 'LOG25': 'L25', 'LOG50': 'L50'}, map_values=True, check_set_errors=True, check_get_errors=True ) class VAR2(VARX): """ Class to handle all the specific definitions needed for VAR2. Common methods are imported from base class. """ def __init__(self, adapter, **kwargs): super().__init__( adapter, "VAR2", **kwargs ) points = Instrument.control( ":PAGE:MEAS:VAR2:POINTS?", ":PAGE:MEAS:VAR2:POINTS %g", """ Sets the number of sweep steps of VAR2. You use this command only if there is an SMU or VSU whose function (FCTN) is VAR2. .. code-block:: python instr.var2.points = 10 """, validator=strict_discrete_set, values=range(1, 128), check_set_errors=True, check_get_errors=True ) class VARD(SCPIUnknownMixin, Instrument): """ Class to handle all the definitions needed for VARD. VARD is always defined in relation to VAR1. """ def __init__(self, adapter, **kwargs): super().__init__( adapter, "Definitions for VARD sweep variable.", **kwargs ) @property def channel_mode(self): channels = ['SMU1', 'SMU2', 'SMU3', 'SMU4', 'VSU1', 'VSU2'] for ch in channels: ch_func = self.ask(f":PAGE:CHAN:{ch}:FUNC?") if ch_func == "VARD": ch_mode = self.ask(f":PAGE:CHAN:{ch}:MODE?") return ch_mode @property def offset(self): """ Sets the OFFSET value of VARD. For each step of sweep, the output values of VAR1' are determined by the following equation: VARD = VAR1 X RATio + OFFSet You use this command only if there is an SMU or VSU whose function is VARD. .. code-block:: python instr.vard.offset = 1 """ value = self.ask(":PAGE:MEAS:VARD:OFFSET?") self.check_errors() return value @offset.setter def offset(self, offset_value): validator = strict_range values = 2 * valid_iv(self.channel_mode) value = validator(offset_value, values) self.write(f":PAGE:MEAS:VARD:OFFSET {value}") self.check_errors() ratio = Instrument.control( ":PAGE:MEAS:VARD:RATIO?", ":PAGE:MEAS:VARD:RATIO %g", """ Sets the RATIO of VAR1'. For each step of sweep, the output values of VAR1' are determined by the following equation: VAR1’ = VAR1 * RATio + OFFSet You use this command only if there is an SMU or VSU whose function (FCTN) is VAR1'. .. code-block:: python instr.vard.ratio = 1 """, ) @property def compliance(self): """ Sets the sweep COMPLIANCE value of VARD. .. code-block:: python instr.vard.compliance = 0.1 """ value = self.ask(":PAGE:MEAS:VARD:COMP?") self.check_errors() return value @compliance.setter def compliance(self, value): validator = strict_range values = 2 * valid_compliance(self.channel_mode) set_value = validator(value, values) self.write(f":PAGE:MEAS:VARD:COMP {set_value}") self.check_errors() def check_current_voltage_name(name): if (len(name) > 6) or not name[0].isalpha(): new_name = 'a' + name[:5] log.info(f"Renaming {name} to {new_name}...") name = new_name return name def valid_iv(channel_mode): if channel_mode == 'V': values = [-200, 200] elif channel_mode == 'I': values = [-1, 1] else: raise ValueError( 'Channel is not in V or I mode. It might be disabled.') return values def valid_compliance(channel_mode): if channel_mode == 'I': values = [-200, 200] elif channel_mode == 'V': values = [-1, 1] else: raise ValueError( 'Channel is not in V or I mode. It might be disabled.') return values