# # 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 ctypes import logging from enum import Enum from pymeasure.instruments.hp.hplegacyinstrument import HPLegacyInstrument, StatusBitsBase from pymeasure.instruments.validators import strict_discrete_set, strict_range log = logging.getLogger(__name__) log.addHandler(logging.NullHandler()) c_uint8 = ctypes.c_uint8 class Status(StatusBitsBase): """ Support-Class with the bit assignments for the 2 status byte(12bits used) of the HP6632A """ _fields_ = [ # Byte 1: Function, Range and Number of Digits ("Error_pending", c_uint8, 1), # bit 7 ("Overcurrent", c_uint8, 1), # bit 6 ("not_assigned", c_uint8, 1), # bit 5 ("Overtempeature", c_uint8, 1), # bit 4 ("Overvoltage", c_uint8, 1), # bit 3 ("Unregulated", c_uint8, 1), # bit 2 ("CCpos", c_uint8, 1), # bit 1 ("CV", c_uint8, 1), # bit 0 # Byte 2: Status Bits ("not_assigned", c_uint8, 4), # bits 16..12 ("NORM", c_uint8, 1), # bit 11 ("FAST", c_uint8, 1), # bit 10 ("CCneg", c_uint8, 1), # bit 9 ("Inhibit_active", c_uint8, 1), # bit 8 ] limits = { "HP6632A": {"Volt_lim": 20.475, "OVP_lim": 22.0, "Cur_lim": 5.118}, "HP6633A": {"Volt_lim": 51.118, "OVP_lim": 55.0, "Cur_lim": 2.0475}, "HP6634A": {"Volt_lim": 102.38, "OVP_lim": 110.0, "Cur_lim": 1.0238}} class HP6632A(HPLegacyInstrument): """ Represents the Hewlett Packard 6632A system power supply and provides a high-level interface for interacting with the instrument. """ status_desc = Status def __init__(self, adapter, name="Hewlett-Packard HP6632A", **kwargs): kwargs.setdefault('read_termination', '\r\n') kwargs.setdefault('send_end', True) super().__init__( adapter, name, **kwargs, ) class ERRORS(Enum): """ Enum class for error messages """ NO_ERR = 0 EEPROM = 1 PON_2ND = 2 DCPON_2MD = 4 NORELAY = 5 NOTHING_SAY = 8 HEADER_EXPECTED = 10 UNRECOGNISED_HEADER = 11 NUMBER_EXPECTED = 20 NUMBER_SYNTAX = 21 OUT_OF_RANGE = 22 COMMA_EXPECTED = 30 TERM_EXPECTED = 31 PARAM_OUT = 41 V_PGM_ERR = 42 I_PGM_ERR = 43 OV_PGM_ERR = 44 DLY_PGM_ERR = 45 MASK_PGM_ERR = 46 MULT_CSAVE_ERR = 50 EEPROM_CJLSUM_ERR = 51 CALMODE_DISABLED = 52 CAL_CHNL_ERR = 53 CAL_FS_ERR = 54 CAL_OFFSET = 55 CAL_JMP_ERR = 59 class ST_ERRORS(Enum): """ Enum class for selftest errors """ NO_ST_ERR = 0 ROM_CKSSUM = 1 RAM_TEST = 2 HPIB_CHIP = 3 HPIB_TIMER_SLOW = 4 HPIB_TIMER_FAST = 5 PSI_ROM_CHKSUM = 11 PSI_RAM_TEST = 12 PSI_TIMER_SLOW = 14 PSI_TIMER_FAST = 15 AD_TEST_HIGH = 16 AD_TEST_LOW = 17 CCCV_ZERO_HIGH = 18 CCCV_ZERO_LOW = 19 CV_REF_HIGH = 20 CV_REF_LOW = 21 CC_REF_HIGH = 22 CC_REF_LOW = 23 DAC_FAIL = 24 EEPROM_CHKSUM = 51 def check_errors(self): """ Method to read the error status register :return error_status: one byte with the error status register content :rtype error_status: int """ # Read the error status register only one time for this method, as # the manual states that reading the error status register also clears it. current_errors = int(self.ask("ERR?")) if current_errors != 0: log.error("HP6632 Error detected: %s", self.ERRORS(current_errors)) return self.ERRORS(current_errors) def check_selftest_errors(self): """ Method to read the error status register :return error_status: one byte with the error status register content :rtype error_status: int """ # Read the error status register only one time for this method, as # the manual states that reading the error status register also clears it. current_errors = int(self.ask("TEST?")) if current_errors != 0: log.error("HP6632 Error detected: %s", self.ERRORS(current_errors)) return self.ST_ERRORS(current_errors) def clear(self): """ Resets the instrument to power-on default settings """ self.write("CLR") delay = HPLegacyInstrument.setting( "DELAY %g", """ A float property that changes the reprogamming delay Default values: 8 ms in FAST mode 80 ms in NORM mode Values will be rounded to the next 4 ms by the instrument """, validator=strict_range, values=[0, 32.768], ) display_active = HPLegacyInstrument.setting( "DIS %d", """ A boot property which controls if the display is enabled """, validator=strict_discrete_set, values={False: 0, True: 1}, map_values=True ) @property def status(self): """ Returns an object representing the current status of the unit. """ # overloading the already existing property because of the different command reply = bytearray(int(self.ask("STS?")).to_bytes( self.status_bytes_count, "little")) return self.status_bits.from_buffer(reply) id = HPLegacyInstrument.measurement( "ID?", """ Reads the ID of the instrument and returns this value for now """, ) current = HPLegacyInstrument.control( "IOUT?", "ISET %g", """ A floating point property that controls the output current of the device. """, dynamic=True, validator=strict_range, values=[0, limits["HP6632A"]["Cur_lim"]], ) over_voltage_limit = HPLegacyInstrument.setting( "OVSET %g", """ A floationg point property that sets the OVP threshold. """, dynamic=True, validator=strict_range, values=[0, limits["HP6632A"]["OVP_lim"]], ) OCP_enabled = HPLegacyInstrument.setting( "OCP %d", """ A bool property which controls if the OCP (OverCurrent Protection) is enabled """, validator=strict_discrete_set, values={False: 0, True: 1}, map_values=True ) output_enabled = HPLegacyInstrument.setting( "OUT %d", """ A bool property which controls if the outputis enabled """, validator=strict_discrete_set, values={False: 0, True: 1}, map_values=True ) @output_enabled.getter def output_enabled(self): """ A bool property which controls if the output is enabled """ output_status = bool(self.status.CV or self.status.CCpos or self.status.CCneg or self.status.Unregulated) return output_status def reset_OVP_OCP(self): """ Resets Overvoltage and Overcurrent protections """ self.write("RST") rom_version = HPLegacyInstrument.measurement( "ROM?", """ Reads the ROM id (software version) of the instrument and returns this value for now """, ) SRQ_enabled = HPLegacyInstrument.setting( "SRQ %d", """ A bool property which controls if the SRQ (ServiceReQuest) is enabled """, validator=strict_discrete_set, values={False: 0, True: 1}, map_values=True ) voltage = HPLegacyInstrument.control( "VOUT?", "VSET %g", """ A floating point proptery that controls the output voltage of the device. """, dynamic=True, validator=strict_range, values=[0, limits["HP6632A"]["Volt_lim"]], ) class HP6633A(HP6632A): """ Represents the Hewlett Packard 6633A system power supply and provides a high-level interface for interacting with the instrument. """ def __init__(self, adapter, name="Hewlett Packard HP6633A", **kwargs): super().__init__(adapter, name, **kwargs) current_values = [0, limits["HP6633A"]["Cur_lim"]] OVP_values = [0, limits["HP6633A"]["OVP_lim"]] voltage_values = [0, limits["HP6633A"]["Volt_lim"]] class HP6634A(HP6632A): """ Represents the Hewlett Packard 6634A system power supply and provides a high-level interface for interacting with the instrument. """ def __init__(self, adapter, name="Hewlett Packard HP6634A", **kwargs): super().__init__(adapter, name, **kwargs) current_values = [0, limits["HP6634A"]["Cur_lim"]] OVP_values = [0, limits["HP6634A"]["OVP_lim"]] voltage_values = [0, limits["HP6634A"]["Volt_lim"]]