# # 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 import math from enum import IntFlag 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 SRQ(ctypes.BigEndianStructure): """Support class for the SRQ handling """ _fields_ = [ ("power_on", c_uint8, 1), ("not_assigned_1", c_uint8, 1), ("calibration", c_uint8, 1), ("front_panel_button", c_uint8, 1), ("internal_error", c_uint8, 1), ("syntax_error", c_uint8, 1), ("not_assigned_2", c_uint8, 1), ("data_ready", c_uint8, 1), ] def __str__(self): """ Returns a pretty formatted string showing the status of the instrument """ ret_str = "" for field in self._fields_: ret_str = ret_str + f"{field[0]}: {hex(getattr(self, field[0]))}\n" return ret_str class Status(StatusBitsBase): """ Support-Class with the bit assignments for the 5 status byte of the HP3478A """ _fields_ = [ # Byte 1: Function, Range and Number of Digits ("function", c_uint8, 3), # bit 5..7 ("range", c_uint8, 3), # bit 2..4 ("digits", c_uint8, 2), # bit 0..1 # Byte 2: Status Bits ("res1", c_uint8, 1), ("ext_trig", c_uint8, 1), ("cal_enable", c_uint8, 1), ("front_rear", c_uint8, 1), ("fifty_hz", c_uint8, 1), ("auto_zero", c_uint8, 1), ("auto_range", c_uint8, 1), ("int_trig", c_uint8, 1), # Byte 3: Serial Poll Mask (SRQ) # ("SRQ_PON", c_uint8, 1), # ("res3", c_uint8, 1), # ("SRQ_cal_error", c_uint8, 1), # ("SRQ_front_panel", c_uint8, 1), # ("SRQ_internal_error", c_uint8, 1), # ("SRQ_syntax_error", c_uint8, 1), # ("res2", c_uint8, 1), # ("SRQ_data_rdy", c_uint8, 1), ("SRQ", SRQ), # Byte 4: Error Information # ("res5", c_uint8, 1), # ("res4", c_uint8, 1), # ("ERR_AD_Link", c_uint8, 1), # ("ERR_AD", c_uint8, 1), # ("ERR_slope", c_uint8, 1), # ("ERR_ROM", c_uint8, 1), # ("ERR_RAM", c_uint8, 1), # ("ERR_cal", c_uint8, 1), ("Error_Status", c_uint8, 8), # Byte 5: DAC Value ("DAC_value", c_uint8, 8), ] class HP3478A(HPLegacyInstrument): """ Represents the Hewlett Packard 3478A 5 1/2 digit multimeter and provides a high-level interface for interacting with the instrument. """ status_desc = Status def __init__(self, adapter, name="Hewlett-Packard HP3478A", **kwargs): kwargs.setdefault('read_termination', '\r\n') kwargs.setdefault('send_end', True) super().__init__( adapter, name, **kwargs, ) # Definitions for different specifics of this instrument MODES = {"DCV": "F1", "ACV": "F2", "R2W": "F3", "R4W": "F4", "DCI": "F5", "ACI": "F6", "Rext": "F7", } INV_MODES = {v: k for k, v in MODES.items()} RANGES = {"DCV": {3E-2: "R-2", 3E-1: "R-1", 3: "R0", 30: "R1", 300: "R2", "auto": "RA"}, "ACV": {3E-1: "R-1", 3: "R0", 30: "R1", 300: "R2", "auto": "RA"}, "R2W": {30: "R1", 300: "R2", 3E3: "R3", 3E4: "R4", 3E5: "R5", 3E6: "R6", 3E7: "R7", "auto": "RA"}, "R4W": {30: "R1", 300: "R2", 3E3: "R3", 3E4: "R4", 3E5: "R5", 3E6: "R6", 3E7: "R7", "auto": "RA"}, "DCI": {3E-1: "R-1", 3: "R0", "auto": "RA"}, "ACI": {3E-1: "R-1", 3: "R0", "auto": "RA"}, "Rext": {3E7: "R7", "auto": "RA"}, } TRIGGERS = { "auto": "T1", "internal": "T1", "external": "T2", "single": "T3", "hold": "T4", "fast": "T5", } class ERRORS(IntFlag): """Enum element for errror bit decoding """ AD_LINK = 32 # AD link error AD_SELFCHK = 16 # AD self check error AD_SLOPE = 8 # AD slope error ROM = 4 # Control ROM error RAM = 2 # RAM selftest failed CALIBRATION = 1 # Calibration checksum error or cal range issue NO_ERR = 0 # Should be obvious # commands/properties for instrument control @property def active_connectors(self): """Return selected connectors ("front"/"back"), based on front-panel selector switch """ selection = self.status.front_rear if selection == 1: return "front" else: return "back" @property def auto_range_enabled(self): """ Property describing the auto-ranging status ====== ============================================ Value Status ====== ============================================ True auto-range function activated False manual range selection / auto-range disabled ====== ============================================ The range can be set with the :py:attr:`range` property """ selection = self.status.auto_range return bool(selection) @property def auto_zero_enabled(self): """ Return auto-zero status, this property can be set ====== ================== Value Status ====== ================== True auto-zero active False auto-zero disabled ====== ================== """ selection = self.status.auto_zero return bool(selection) @auto_zero_enabled.setter def auto_zero_enabled(self, value): az_set = int(value) az_str = "Z" + str(int(strict_discrete_set(az_set, [0, 1]))) self.write(az_str) @property def calibration_enabled(self): """Return calibration enable switch setting, based on front-panel selector switch ====== =================== Value Status ====== =================== True calbration possible False calibration locked ====== =================== """ selection = self.status.cal_enable return bool(selection) 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 = self.error_status if current_errors != 0: log.error("HP3478A error detected: %s", self.ERRORS(current_errors)) return self.ERRORS(current_errors) error_status = HPLegacyInstrument.measurement( "E", """Checks the error status register """, cast=int, ) def display_reset(self): """ Reset the display of the instrument. """ self.write("D1") display_text = HPLegacyInstrument.setting( "D2%s", """Displays up to 12 upper-case ASCII characters on the display. """, set_process=(lambda x: str.upper(x[0:12])), ) display_text_no_symbol = HPLegacyInstrument.setting( "D3%s", """Displays up to 12 upper-case ASCII characters on the display and disables all symbols on the display. """, set_process=(lambda x: str.upper(x[0:12])), ) measure_ACI = HPLegacyInstrument.measurement( MODES["ACI"], """ Returns the measured value for AC current as a float in A. """, ) measure_ACV = HPLegacyInstrument.measurement( MODES["ACV"], """ Returns the measured value for AC Voltage as a float in V. """, ) measure_DCI = HPLegacyInstrument.measurement( MODES["DCI"], """ Returns the measured value for DC current as a float in A. """, ) measure_DCV = HPLegacyInstrument.measurement( MODES["DCV"], """ Returns the measured value for DC Voltage as a float in V. """, ) measure_R2W = HPLegacyInstrument.measurement( MODES["R2W"], """ Returns the measured value for 2-wire resistance as a float in Ohm. """, ) measure_R4W = HPLegacyInstrument.measurement( MODES["R4W"], """ Returns the measured value for 4-wire resistance as a float in Ohm. """, ) measure_Rext = HPLegacyInstrument.measurement( MODES["Rext"], """ Returns the measured value for extended resistance mode (>30M, 2-wire) resistance as a float in Ohm. """, ) @property def mode(self): """Return current selected measurement mode, this propery can be set. Allowed values are ==== ============================================================== Mode Function ==== ============================================================== ACI AC current ACV AC voltage DCI DC current DCV DC voltage R2W 2-wire resistance R4W 4-wire resistance Rext extended resistance method (requires additional 10 M resistor) ==== ============================================================== """ current_mode = self.INV_MODES["F" + str(self.status.function)] return current_mode @mode.setter def mode(self, value): mode_set = self.MODES[strict_discrete_set(value, self.MODES)] self.write(mode_set) @property def range(self): """Returns the current measurement range, this property can be set. Valid values are : ==== ======================================= Mode Range ==== ======================================= ACI 0.3, 3, auto ACV 0.3, 3, 30, 300, auto DCI 0.3, 3, auto DCV 0.03, 0.3, 3, 30, 300, auto R2W 30, 300, 3000, 3E4, 3E5, 3E6, 3E7, auto R4W 30, 300, 3000, 3E4, 3E5, 3E6, 3E7, auto Rext 3E7, auto ==== ======================================= """ cur_mode = self.INV_MODES["F" + str(self.status.function)] if cur_mode == "DCV": correction_factor = 3 elif cur_mode in ["ACV", "ACI", "DCI"]: correction_factor = 2 else: correction_factor = 0 current_range = 3 * math.pow(10, self.status.range - correction_factor) return current_range @range.setter def range(self, value): cur_mode = self.mode value = strict_discrete_set(value, self.RANGES[cur_mode]) set_range = self.RANGES[cur_mode][value] self.write(set_range) @property def resolution(self): """Returns current selected resolution, this property can be set. Possible values are 3,4 or 5 (for 3 1/2, 4 1/2 or 5 1/2 digits of resolution) """ number_of_digit = 6 - self.status.digits return number_of_digit @resolution.setter def resolution(self, value): resolution_string = "N" + str(strict_discrete_set(value, [3, 4, 5])) self.write(resolution_string) @property def SRQ_mask(self): """Return current SRQ mask, this property can be set, bit assigment for SRQ: ========= ========================== Bit (dec) Description ========= ========================== 1 SRQ when Data ready 4 SRQ when Syntax error 8 SRQ when internal error 16 front panel SQR button 32 SRQ by invalid calibration ========= ========================== """ return self.status.SRQ @SRQ_mask.setter def SRQ_mask(self, value): self.write(f"M{strict_range(value, [0, 63]):02o}") @property def trigger(self): """Return current selected trigger mode, this property can be set Possibe values are: ======== =========================================== Value Meaning ======== =========================================== auto automatic trigger (internal) internal automatic trigger (internal) external external trigger (connector on back or GET) hold holds the measurement fast fast trigger for AC measurements ======== =========================================== """ status = self.status i_trig = status.int_trig e_trig = status.ext_trig if i_trig == 0: if e_trig == 0: trigger_mode = "hold" else: trigger_mode = "external" else: trigger_mode = "internal" return trigger_mode @trigger.setter def trigger(self, value): trig_set = self.TRIGGERS[strict_discrete_set(value, self.TRIGGERS)] self.write(trig_set) @property def calibration_data(self): """Read or write the calibration data as an array of 256 values between 0 and 15. The calibration data of an HP 3478A is stored in a 256x4 SRAM that is permanently powered by a 3v Lithium battery. When the battery runs out, the calibration data is lost, and recalibration is required. When read, this property fetches and returns the calibration data so that it can be backed up. When assigned a value, it similarly expects an array of 256 values between 0 and 15, and writes the values back to the instrument. When writing, exceptions are raised for the following conditions: * The CAL ENABLE switch at the front of the instrument is not set to ON. * The array with values does not contain exactly 256 elements. * The array with values does not pass a verification check. IMPORTANT: changing the calibration data results in permanent loss of the previous data. Use with care! """ cal_data = [] for addr in range(0, 256): # To fetch one nibble: 'W
', where address is a raw 8-bit number. cmd = bytes([ord('W'), addr]) self.write_bytes(cmd) rvalue = self.read_bytes(1)[0] # 'W' command reads a nibble from the SRAM, but then adds a value of 64 to return # it as an ASCII value. if rvalue < 64 or rvalue >= 80: raise Exception("calibration nibble out of range") cal_data.append(rvalue-64) return cal_data @calibration_data.setter def calibration_data(self, cal_data): """Setter to write the calibration data. """ if not self.calibration_enabled: raise Exception("CAL ENABLE switch not set to ON") self.write_calibration_data(cal_data, True) def write_calibration_data(self, cal_data, verify_calibration_data=True): """Method to write calibration data. The cal_data parameter format is the same as the ``calibration_data`` property. Verification of the cal_data array can be bypassed by setting ``verify_calibration_data`` to ``False``. """ if verify_calibration_data and not self.verify_calibration_data(cal_data): raise ValueError("cal_data verification fail.") for addr in range(0, 256): # To write one nibble: 'X
', where address and byte are raw 8-bit numbers. cmd = bytes([ord('X'), addr, cal_data[addr]]) self.write_bytes(cmd) pass def verify_calibration_entry(self, cal_data, entry_nr): """Verify the checksum of one calibration entry. Expects an array of 256 values with calibration data, and an entry number from 0 to 18. Returns True when the checksum of the specified calibration entry is correct. """ if len(cal_data) != 256: raise Exception("cal_data must contain 256 values") sum = 0 for idx in range(0, 13): val = cal_data[entry_nr*13 + idx + 1] if idx != 11: sum += val else: sum += val*16 return sum == 255 def verify_calibration_data(self, cal_data): """Verify the checksums of all calibration entries. Expects an array of 256 values with calibration data. :return calibration_correct: True when all checksums are correct. :rtype calibration_correct: boolean """ for entry_nr in range(0, 19): if entry_nr in [5, 16, 18]: continue if not self.verify_calibration_entry(cal_data, entry_nr): return False return True