# # 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 NON INFRINGEMENT. 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 logging import math import re import time from pymeasure.instruments import Instrument from pymeasure.instruments.validators import strict_range from pymeasure.instruments.validators import strict_discrete_set from enum import IntFlag log = logging.getLogger(__name__) log.addHandler(logging.NullHandler()) class EurotestHPP120256(Instrument): """ Represents the Euro Test High Voltage DC Source model HPP-120-256 and provides a high-level interface for interacting with the instrument using the Euro Test command set (Not SCPI command set). .. code-block:: python hpp120256 = EurotestHPP120256("GPIB0::20::INSTR") print(hpp120256.id) print(hpp120256.lam_status) print(hpp120256.status) hpp120256.ramp_to_zero(100.0) hpp120256.voltage_ramp = 50.0 # V/s hpp120256.current_limit = 2.0 # mA inst.kill_enabled = True # Enable over-current protection time.sleep(1.0) # Give time to enable kill inst.output_enabled = True time.sleep(1.0) # Give time to output on abs_output_voltage_error = 0.02 # kV hpp120256.wait_for_output_voltage_reached(abs_output_voltage_error, 1.0, 40.0) # Here voltage HV output should be at 0.0 kV print("Setting the output voltage to 1.0kV...") hpp120256.voltage_setpoint = 1.0 # kV # Now HV output should be rising to reach the 1.0kV at 50.0 V/s hpp120256.wait_for_output_voltage_reached(abs_output_voltage_error, 1.0, 40.0) # Here voltage HV output should be at 1.0 kV hpp120256.shutdown() hpp120256.wait_for_output_voltage_reached(abs_output_voltage_error, 1.0, 60.0) # Here voltage HV output should be at 0.0 kV inst.output_enabled = False # Now the HV voltage source is in safe state """ VOLTAGE_RANGE = [0.0, 12.0] # kVolts CURRENT_RANGE = [0.0, 25.0] # mAmps VOLTAGE_RAMP_RANGE = [10, 3000] # V/s COMMAND_DELAY = 0.2 # s response_encoding = "iso-8859-2" regex = re.compile(r'([+-]?([\d]*\.)?[\d]+)') def __init__(self, adapter, name="Euro Test High Voltage DC Source model HPP-120-256", query_delay=0.1, write_delay=0.4, timeout=5000, **kwargs): super().__init__( adapter, name, write_termination="\n", read_termination="", send_end=True, includeSCPI=False, timeout=timeout, **kwargs ) self.write_delay = write_delay self.query_delay = query_delay self.last_write_timestamp = 0.0 # #################################### # # EuroTest-Command set. Non SCPI commands. # #################################### voltage_setpoint = Instrument.control( "STATUS,U", "U,%.3fkV", """Control the voltage set-point in kVolts (float strictly from 0 to 12).""", # getter device response: "U, RANGE=3.000kV, VALUE=2.458kV" validator=strict_range, values=VOLTAGE_RANGE, get_process=lambda r: float(EurotestHPP120256.regex.search(r[2].strip()).groups()[0]) ) current_limit = Instrument.control( "STATUS,I", "I,%.3fmA", """Control the current limit in mAmps (float strictly from 0 to 25).""", # When this property acts as get, the instrument will return a string like this: # "I, RANGE=5000mA, VALUE=1739mA", then current_limit will return 1739.0, # hence the convenience of the get_process. validator=strict_range, values=CURRENT_RANGE, get_process=lambda r: float(EurotestHPP120256.regex.search(r[2].strip()).groups()[0]) ) voltage_ramp = Instrument.control( "STATUS,RAMP", "RAMP,%dV/s", """Control the voltage ramp in Volts/second (int strictly from 10 to 3000).""", # When this property acts as get, the instrument will return a string like this: # "RAMP, RANGE=3000V/s, VALUE=1000V/s", then voltage_ramp will return 1000.0, # hence the convenience of the get_process. validator=strict_range, values=VOLTAGE_RAMP_RANGE, get_process=lambda r: float(EurotestHPP120256.regex.search(r[2].strip()).groups()[0]) ) voltage = Instrument.measurement( "STATUS,MU", """Measure the actual output voltage in kVolts (float).""", # This property is a get so, the instrument will return a string like this: # "U, RANGE=3.000kV, VALUE=2.458kV", then voltage will return 2458.0, # hence the convenience of the get_process. get_process=lambda r: float(EurotestHPP120256.regex.search(r[2].strip()).groups()[0]) ) voltage_range = Instrument.measurement( "STATUS,MU", """Measure the actual output voltage range in kVolts (float).""", # This property is a get so, the instrument will return a string like this: # "U, RANGE=3.000kV, VALUE=2.458kV", then voltage_range will return 3000.0, # hence the convenience of the get_process. get_process=lambda r: float(EurotestHPP120256.regex.search(r[1]).groups()[0]) ) current = Instrument.measurement( "STATUS,MI", """Measure the actual output current in mAmps (float).""", # This property is a get so, the instrument will return a string like this: # "I, RANGE=5000mA, VALUE=1739mA", then current will return a 1739.0, # hence the convenience of the get_process.""" get_process=lambda r: float(EurotestHPP120256.regex.search(r[2].strip()).groups()[0]) ) current_range = Instrument.measurement( "STATUS,MI", """Measure the actual output current range in mAmps (float).""", # This property is a get so, the instrument will return a string like this: # "I, RANGE=5000mA, VALUE=1739mA, then current_range will return a 5000.0, # hence the convenience of the get_process. get_process=lambda r: float(EurotestHPP120256.regex.search(r[1].strip()).groups()[0]) ) kill_enabled = Instrument.control( "STATUS,DI", "KILL,%s", """Control the instrument kill enable (boolean).""", # When Kill is enabled yellow led is flashing and the output # will be shut OFF permanently without ramp if Iout > IOUTmax. validator=strict_discrete_set, values={True: 'ENable', False: 'DISable'}, map_values=True, get_process=lambda r: EurotestHPP120256.EurotestHPP120256Status( int(r[1].strip()[:-1].encode(EurotestHPP120256.response_encoding). decode('utf-8', 'ignore'), 2) ) == EurotestHPP120256.EurotestHPP120256Status.KILL_ENABLE ) output_enabled = Instrument.control( "STATUS,DI", "HV,%s", """Control the instrument output enable (boolean).""", # When output voltage is enabled green led is ON and the # voltage_setting will be present on the output. validator=strict_discrete_set, values={True: 'ON', False: 'OFF'}, map_values=True, get_process=lambda r: EurotestHPP120256.EurotestHPP120256Status( int(r[1].strip()[:-1].encode(EurotestHPP120256.response_encoding). decode('utf-8', 'ignore'), 2) ) == EurotestHPP120256.EurotestHPP120256Status.OUTPUT_ON ) id = Instrument.measurement( "ID", """Get the identification of the instrument (string) """, get_process=lambda r: r[1].strip().encode(EurotestHPP120256.response_encoding).decode('utf-8', 'ignore') ) status = Instrument.measurement( "STATUS,DI", """Get the instrument status (EurotestHPP120256Status).""", # Every bit indicates the state of one subsystem of the HV Source. # response DI, b15 b14 b13 b12 b11 b10 b9 b8 b7 b6 b5 b4 b3 b2 b1 b0, # 0 1 # IpErr b15 no input error input error # Ramp b14 no ramp ramp # CutOut b13 - emergency off # TpErr b12 no trip error trip error # F3 b11 reserved # F2 b10 reserved # menu1 b9 submenu off submenu on # menu0 b8 menu off menu on # err b7 no error error # Creg b6 no current control current control # Vreg b5 no voltage control voltage control # pol b4 negative positive # inh b3 no ext. inhibit external inhibit # local b2 remote local # kilena b1 kill disable kill enable # on b0 off high voltage is ON get_process=lambda r: EurotestHPP120256.EurotestHPP120256Status( int(r[1].strip()[:-1].encode(EurotestHPP120256.response_encoding). decode('utf-8', 'ignore'), 2) ) ) lam_status = Instrument.measurement( "STATUS,LAM", """Get the instrument lam status (string).""", # LAM status is the status of the unit from the point # of view of the process. Fo example, as a response of asking STATUS,LAM, the HV # voltage could response one of the messages from the next list: # LAM,ERROR External Inhibit occurred during Kill enable # LAM,INHIBIT External Inhibit occurred # LAM,TRIP ERROR Software current trip occurred # LAM,INPUT ERROR Wrong command received # LAM,OK Status OK get_process=lambda r: r[1].strip().encode(EurotestHPP120256.response_encoding).decode('utf-8', 'ignore') ) def emergency_off(self): """ The output of the HV source will be switched OFF permanently and the values of the voltage and current settings set to zero""" log.info("Sending emergency off command to the instrument.") self.write("EMCY OFF") def shutdown(self, voltage_rate=200.0): """ Change the output voltage setting (V) to zero and the ramp speed - voltage_rate (V/s) of the output voltage. After calling shutdown, if the HV voltage output > 0 it should drop to zero at a certain rate given by the voltage_rate parameter. :param voltage_rate: indicates the changing rate (V/s) of the voltage output """ log.info(f"Executing the shutdown function with voltage_rate: {voltage_rate} V/s.") self.ramp_to_zero(voltage_rate) super().shutdown() def ramp_to_zero(self, voltage_rate=200.0): """ Sets the voltage output setting to zero and the ramp setting to a value determined by the voltage_rate parameter. In summary, the method conducts (ramps) the voltage output to zero at a determinated voltage changing rate (ramp in V/s). :param voltage_rate: Is the changing rate (ramp in V/s) for the ramp setting """ log.info(f"Executing the ramp_to_zero function with ramp: {voltage_rate} V/s.") self.voltage_ramp = voltage_rate self.voltage_setpoint = 0 def wait_for_output_voltage_reached(self, voltage_setpoint, abs_output_voltage_error=0.03, check_period=1.0, timeout=60.0): """ Wait until HV voltage output reaches the voltage setpoint. Checks the voltage output every check_period seconds and raises an exception if the voltage output doesn't reach the voltage setting until the timeout time. :param voltage_setpoint: the voltage in kVolts setted in the HV power supply which should be present at the output after some time (depends on the ramp setting). :param abs_output_voltage_error: absolute error in kVolts for being considered an output voltage reached. :param check_period: voltage output will be measured every check_period (seconds) time. :param timeout: time (seconds) give to the voltage output to reach the voltage setting. :return: None :raises: Exception if the voltage output can't reach the voltage setting before the timeout completes (seconds). """ log.info("Executing the wait_for_output_voltage_reached function.") ref_time = time.time() future_time = ref_time + timeout log.debug(f"\tWaiting for voltage output set. " f"Reading output voltage every {check_period} seconds.\n" f"\tTimeout: {timeout} seconds.") while True: actual_time = time.time() time.sleep(check_period) # wait for voltage output reaches the voltage output setting voltage_output = self.voltage # check if voltage_output is set. If so then no more wait if math.isclose(voltage_output, voltage_setpoint, rel_tol=0.0, abs_tol=abs_output_voltage_error): break log.debug("voltage_output_valid_range: " "[" + str(voltage_setpoint - abs_output_voltage_error) + ", " + str(voltage_setpoint + abs_output_voltage_error) + "]") log.debug("voltage_output: " + str(voltage_output)) log.debug(f"Elapsed time: {round(actual_time - ref_time, ndigits=1)} seconds.") if actual_time > future_time: self.shutdown() # in case the voltage were applied at the output raise TimeoutError("Timeout for wait_for_output_voltage_reached function") log.info("Waiting for voltage output set done.") # Wrapper functions for the Adapter object def write(self, command, **kwargs): """Overrides Instrument write method for including write_delay time after the parent call. :param command: command string to be sent to the instrument """ actual_write_delay = time.time() - self.last_write_timestamp time.sleep(max(0, self.write_delay - actual_write_delay)) super().write(command, **kwargs) self.last_write_timestamp = time.time() def ask(self, command): """ Overrides Instrument ask method for including query_delay time on parent call. :param command: Command string to be sent to the instrument. :returns: String returned by the device without read_termination. """ return super().ask(command, self.query_delay) class EurotestHPP120256Status(IntFlag): """ Auxiliary class create for translating the instrument 16bits_status_string into an Enum_IntFlag that will help to the user to understand such status. """ # Status response from the instrument has to be interpreted as follows: # # response DI, b15 b14 b13 b12 b11 b10 b9 b8 b7 b6 b5 b4 b3 b2 b1 b0, # bit = 0,1 # IpErr b15 no input error input error # Ramp b14 no ramp ramp # CutOut b13 - emergency off # TpErr b12 no trip error trip error # F3 b11 reserved # F2 b10 reserved # menu1 b9 submenu off submenu on # menu0 b8 menu off menu on # err b7 no error error # Creg b6 no current control current control # Vreg b5 no voltage control voltage control # pol b4 negative positive # inh b3 no ext. inhibit external inhibit # local b2 remote local # kilena b1 kill disable kill enable # on b0 off high voltage is ON # # For example, a status_string = "0100000000000111" will be translated to # EurotestHPP120256_status.RAMP|LOCAL|KILL_ENABLE|OUTPUT_ON INPUT_ERROR = 32768 RAMP = 16384 EMERGENCY_OFF = 8192 TRIP_ERROR = 4096 F3 = 2048 F2 = 1024 SUBMENU_ON = 512 MENU_ON = 256 ERROR = 128 CURRENT_CONTROL = 64 VOLTAGE_CONTROL = 32 POLARIZATION_POSITIVE = 16 EXTERNAL_INHIBIT = 8 LOCAL = 4 KILL_ENABLE = 2 OUTPUT_ON = 1