# # 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 import numpy as np 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 c_uint16 = ctypes.c_uint16 c_uint32 = ctypes.c_uint32 class Status(StatusBitsBase): """ A bitfield structure containing the assignments for the status decoding """ _pack_ = 1 _fields_ = [ # Byte 0: Function, Range and Number of Digits ("Format", c_uint8, 1), # Bit 7 ("SRQ", c_uint8, 3), # bit 4..6 ("Trigger", c_uint8, 2), # bit 2..3 ("Range", c_uint8, 2), # bit 0..1 # Byte 1 & 2: ("Number", c_uint16, 16), # Byte 1: # ("NRDGS_MSD", c_uint8, 4), # ("NRDGS_2SD", c_uint8, 4), # Byte 2: # ("NRDGS_3SD", c_uint8, 4), # ("NRDGS_LSD", c_uint8, 4), ("not_used", c_uint8, 4), ("Delay", c_uint32, 28), # Byte 3: # ("Not_Used", c_uint8, 4), # ("Delay_MSD", c_uint8, 4), # Byte 4: # ("Delay_2SD", c_uint8, 4), # ("Delay_3SD", c_uint8, 4), # Byte 5: # ("Delay_4SD", c_uint8, 4), # ("Delay_5SD", c_uint8, 4), # Byte 6: # ("Delay_6SD", c_uint8, 4), # ("Delay_LSD", c_uint8, 4), ] @staticmethod def _decode_range(r): """Method to decode current range :param range_undecoded: int to be decoded :return cur_range: float value representing the active measurement range :rtype cur_range: float """ # range decoding # (cf table 3-2, page 3-5 of the manual, HPAK document 9018-05946) decode_map = { 0: math.nan, 1: 0.1, 2: 10.0, 3: 1.0, } return decode_map[r] @staticmethod def _decode_trigger(t): """Method to decode trigger mode :param status_bytes: list of bytes to be decoded :return trigger_mode: string with the current trigger mode :rtype trigger_mode: str """ decode_map = { 0: "INVALID", 1: "internal", 2: "external", 3: "hold/manual" } return decode_map[t] _get_process_ = { "Number": StatusBitsBase._convert_from_bcd, "Delay": StatusBitsBase._convert_from_bcd, "Range": _decode_range, "Trigger": _decode_trigger, } 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]}: {getattr(self, field[0])}\n" return ret_str class PackedBits(ctypes.BigEndianStructure): """ A bitfield structure containing the assignments for the data transfer in packed/binary mode """ _pack_ = 1 _fields_ = [ ("range", c_uint8, 2), # bit 0..1 ("sign_bit", c_uint8, 1), ("MSD", c_uint8, 1), ("SSD", c_uint8, 4), ("TSD", c_uint8, 4), ("LSD", c_uint8, 4), ] def __float__(self): """ Return a float value from the packed data of the HP3437A """ # range decoding # (cf table 3-2, page 3-5 of the manual, HPAK document 9018-05946) decode_map = { 1: 0.1, 2: 10.0, 3: 1.0, } cur_range = decode_map[self.range] signbit = 1 if self.sign_bit == 0: signbit = -1 return ( cur_range * signbit * ( self.MSD + self.SSD / 10 + self.TSD / 100 + self.LSD / 1000 ) ) class HP3437A(HPLegacyInstrument): """Represents the Hewlett Packard 3737A system voltmeter and provides a high-level interface for interacting with the instrument. """ status_desc = Status pb_desc = PackedBits def __init__(self, adapter, name="Hewlett-Packard HP3437A", **kwargs): super().__init__( adapter, name, **kwargs, ) # Definitions for different specifics of this instrument RANGE = { 1e-1: "R1", 1: "R2", 10: "R3", } TRIGGERS = { "internal": "T1", "external": "T2", "hold": "T3", "manual": "T3", } class SRQ(IntFlag): """Enum element for SRQ mask bit decoding""" DATA_READY = 4 IGNORE_TRIGGER = 2 INVALID_PROGRAM = 1 def _unpack_data(self, data): """ Method to unpack the data from the returned bytes in packed mode :param data: list of bytes to be decoded :return ret_data: float value """ ret_data = PackedBits.from_buffer(bytearray(data)) return float(ret_data) # commands overwriting the base implementation def read_data(self): """ Reads measured data from instrument, returns a np.array. (This function also takes care of unpacking the data if required) :return data: np.array containing the data """ # Adjusting the timeout to match the number of counts and the delay current_timeout = self.adapter.connection.timeout time_needed = self.number_readings * self.delay new_timeout = min(1e6, time_needed * 3 * 1000) # safety factor 3 if new_timeout > current_timeout: if new_timeout >= 1e6: # Disables timeout if measurement would take more then 1000 sec log.info("HP3437A: timeout deactivated") self.adapter.connection.timeout = new_timeout log.info("HP3437A: timeout changed to %g", new_timeout) read_data = self.read_bytes(-1) # check if data is in packed format format if self.talk_ascii: return_value = np.array(read_data[:-2].decode("ASCII").split(","), dtype=float) else: processed_data = [] for i in range(0, len(read_data), 2): processed_data.append(self._unpack_data(read_data[i : i + 2])) # noqa: E203 return_value = np.array(processed_data) self.adapter.connection.timeout = current_timeout return return_value # commands/properties for instrument control def check_errors(self): """ As this instrument does not have a error indication bit, this function always returns an empty list. """ return [] @property def talk_ascii(self): """ A boolean property, True if the instrument is set to ASCII-based communication. This property can be set. """ return bool(self.status.Format) @talk_ascii.setter def talk_ascii(self, value): if value: self.write("F1") else: self.write("F2") @property def delay(self): """Return the value (float) for the delay between two measurements, this property can be set, valid range: 100ns - 0.999999s """ return self.status.Delay * 1e-7 @delay.setter def delay(self, value): delay_str = ( "D." + format(strict_range(value, [0, 0.9999999]) * 10e6, "07.0f") + "S" ) self.write(delay_str) @property def number_readings(self): """Return value (int) for the number of consecutive measurements, this property can be set, valid range: 0 - 9999 """ return self.status.Number @number_readings.setter def number_readings(self, value): number_str = "N" + str(strict_range(value, [0, 9999])) + "S" self.write(number_str) @property def range(self): """Return the current measurement voltage range. This property can be set, valid values: 0.1, 1, 10 (V). .. Note:: This instrument does not have autorange capability. Overrange will be in indicated as 0.99,9.99 or 99.9 """ return self.status.Range @range.setter def range(self, value): range_str = "R" + format( round(math.log10(strict_discrete_set(value, [0.1, 1, 10])) + 2), "d" ) self.write(range_str) @property def SRQ_mask(self): """Return current SRQ mask, this property can be set, bit assignment for SRQ: ========= ========================== Bit (dec) Description ========= ========================== 1 SRQ when invalid program 2 SRQ when trigger is ignored 4 SRQ when data ready ========= ========================== """ mask = self.status.SRQ return self.SRQ(mask) @SRQ_mask.setter def SRQ_mask(self, value): mask_str = "E" + format(strict_range(value, [0, 7]), "o") + "S" self.write(mask_str) @property def trigger(self): """Return current selected trigger mode, this property can be set, Possible values are: =========== =========================================== Value Explanation =========== =========================================== internal automatic trigger (internal) external external trigger (connector on back or GET) hold/manual holds the measurement/issues a manual trigger =========== =========================================== """ return self.status.Trigger @trigger.setter def trigger(self, value): trig_set = self.TRIGGERS[strict_discrete_set(value, self.TRIGGERS)] self.write(trig_set)