# # 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 logging from warnings import warn from .adapter import Adapter log = logging.getLogger(__name__) log.addHandler(logging.NullHandler()) try: import vxi11 except ImportError: log.warning('Failed to import vxi11 package, which is required for the VXI11Adapter') class VXI11Adapter(Adapter): """ VXI11 Adapter class. Provides a adapter object that wraps around the read, write and ask functionality of the vxi11 library. .. deprecated:: 0.11 Use VISAAdapter instead. :param host: string containing the visa connection information. :param preprocess_reply: (deprecated) optional callable used to preprocess strings received from the instrument. The callable returns the processed string. """ def __init__(self, host, preprocess_reply=None, **kwargs): super().__init__(preprocess_reply=preprocess_reply, query_delay=kwargs.pop('query_delay', 0)) warn("Deprecated, use VISAAdapter instead.", FutureWarning) # Filter valid arguments that can be passed to vxi instrument valid_args = ["name", "client_id", "term_char"] self.conn_kwargs = {} for key in kwargs: if key in valid_args: self.conn_kwargs[key] = kwargs[key] self.connection = vxi11.Instrument(host, **self.conn_kwargs) def _write(self, command, **kwargs): """Write a string command to the instrument appending `write_termination`. :param str command: Command string to be sent to the instrument (without termination). :param kwargs: Keyword arguments for the connection itself. """ self.connection.write(command) def _read(self, **kwargs): """Read up to (excluding) `read_termination` or the whole read buffer. :param kwargs: Keyword arguments for the connection itself. :returns str: ASCII response of the instrument (excluding read_termination). """ return self.connection.read() def ask(self, command): """ Wrapper function for the ask command using the vx11 interface. .. deprecated:: 0.11 Call `Instrument.ask` instead. :param command: string with the command that will be transmitted to the instrument. :returns string containing a response from the device. """ warn("Do not call `Adapter.ask`, but `Instrument.ask` instead.", FutureWarning) return self.connection.ask(command) def write_raw(self, command): """Write bytes to the device. .. deprecated:: 0.11 Use `write_bytes` instead. """ warn("Use `write_bytes` instead.", FutureWarning) self.write_bytes(command) def _write_bytes(self, command, **kwargs): """Write the bytes `content` to the instrument. :param bytes content: The bytes to write to the instrument. :param kwargs: Keyword arguments for the connection itself. .. note:: vx11 adds the term_char even for writing_bytes. """ # Note: vxi11.write_raw adds the term_char! self.connection.write_raw(command, **kwargs) def read_raw(self): """Read bytes from the device. .. deprecated:: 0.11 Use `read_bytes` instead. """ warn("Use `read_bytes` instead.", FutureWarning) return self.read_bytes(-1) def _read_bytes(self, count, break_on_termchar=False, **kwargs): """Read a certain number of bytes from the instrument. :param int count: Number of bytes to read. A value of -1 indicates to read the whole read buffer. :param bool break_on_termchar: Stop reading at a termination character. :param kwargs: Keyword arguments for the connection itself. :returns bytes: Bytes response of the instrument (including termination). """ if self.connection.term_char and not break_on_termchar: read_termination = self.connection.term_char self.connection.term_char = None try: return self.connection.read_raw(count, **kwargs) finally: self.connection.term_char = read_termination else: return self.connection.read_raw(count, **kwargs) def ask_raw(self, command): """ Wrapper function for the ask_raw command using the vx11 interface. .. deprecated:: 0.11 Use `Instrument.write_bytes` and `Instrument.read_bytes` instead. :param command: binary string with the command that will be transmitted to the instrument :returns binary string containing the response from the device. """ warn("Use `Instrument.write_bytes` and `Instrument.read_bytes` instead.", FutureWarning) return self.connection.ask_raw(command) def __repr__(self): return f''