Source code for

A wrapper around the :class:`~.benhw32.Bentham32` class.
from __future__ import annotations

import inspect
import os

from msl.loadlib import Client64

from import Connection
from import BenthamError
from import register
from .errors import BI_OK
from .errors import ERROR_CODES
from .tokens import BenMono
from .tokens import MonochromatorCurrentWL

[docs] @register(manufacturer=r'Bentham', model=r'[D]*TMc300') class Bentham(Connection): def __init__(self, record): """A wrapper around the :class:`~.benhw32.Bentham32` class. This class can be used with either a 32- or 64-bit Python interpreter to call the 32-bit functions in ``benhw32_cdecl.dll``. The :attr:`` for a Bentham connection supports the following key-value pairs in the :ref:`connections-database`:: 'cfg': str, the path to the System.cfg file [default: None] 'atr': str, the path to the System.atr file [default: None] If the ``cfg`` and ``atr`` values are not defined in the :ref:`connections-database` then you will have to call :meth:`build_system_model`, :meth:`load_setup` and :meth:`initialise` (in that order) to configure the SDK. Do not instantiate this class directly. Use the :meth:`~.EquipmentRecord.connect` method to connect to the equipment. Parameters ---------- record : :class:`~.EquipmentRecord` A record from an :ref:`equipment-database`. """ self._is_connected = False super(Bentham, self).__init__(record) self.set_exception_class(BenthamError) path = record.connection.address[5:] head, tail = os.path.split(path) self._tail = tail self.log_debug('Starting 32-bit server for %s', tail) # the IEEE_32M.dll library must be available on PATH env_path = [head, os.path.join(head, 'IEEE', 'Dummy')] self._client = Client64( 'benhw32', append_sys_path=os.path.dirname(__file__), append_environ_path=env_path, lib_path=path ) self._hw_id = None cfg_path ='cfg') atr_path ='atr') if cfg_path and atr_path: self.build_system_model(cfg_path) self.load_setup(atr_path) self.initialise() self._is_connected = True
[docs] def auto_measure(self): ret, reading = self._client.request32('auto_measure') self.errcheck(ret) return reading
[docs] def build_system_model(self, path): """Set the model configuration file. Parameters ---------- path : :class:`str` The path to the ``System.cfg`` file. """ if not os.path.isfile(path): raise OSError('Cannot find {}'.format(path)) ret, error_report = self._client.request32('build_system_model', path) self.errcheck(ret, path, append_msg=error_report) return ret
[docs] def disconnect(self): """Disconnect from the SDK and from the 32-bit server.""" if self._is_connected: self.errcheck(self._client.request32('close')) self.log_debug('Stopping 32-bit server for %s', self._tail) self.shutdown_server32() self._is_connected = False
[docs] def errcheck(self, result, *args, **kwargs): """Checks whether a function call to the SDK was successful.""" frame = inspect.getouterframes(inspect.currentframe())[1] self.log_debug('%s.%s%s -> %s', self.__class__.__name__, frame.function, args, result) if result != BI_OK: e, m = ERROR_CODES[result] try: append_msg = kwargs['append_msg'] except KeyError: append_msg = '' self.raise_exception('{0}: {1} {2}'.format(e, m, append_msg)) return result
[docs] def get(self, hw_id, token, index): ret, value = self._client.request32('get', hw_id, token, index) self.errcheck(ret, hw_id, token, index) return value
[docs] def get_component_list(self): ret, components = self._client.request32('get_component_list') self.errcheck(ret) return components
[docs] def get_hardware_type(self, hw_id): ret, hardware_type = self._client.request32('get_hardware_type', hw_id) self.errcheck(ret, hw_id) return hardware_type
[docs] def get_mono_items(self, hw_id): ret, items = self._client.request32('get_mono_items', hw_id) self.errcheck(ret, hw_id) return items
@property def wavelength(self): if self._hw_id is None: for item in self.get_component_list(): if self.get_hardware_type(item) == BenMono: self._hw_id = item break if self._hw_id is None: raise ValueError('Cannot get wavelength. BenMono is not a hardware type.') return self.get(self._hw_id, MonochromatorCurrentWL, 0) @wavelength.setter def wavelength(self, wavelength): self.select_wavelength(wavelength)
[docs] def initialise(self): """Initialize the connection.""" return self.errcheck(self._client.request32('initialise'))
[docs] def load_setup(self, path): """Load the setup file. Parameters ---------- path : :class:`str` The path to the ``System.atr`` file. """ if not os.path.isfile(path): raise OSError('Cannot find {}'.format(path)) return self.errcheck(self._client.request32('load_setup', path), path)
[docs] def park(self): return self.errcheck(self._client.request32('park'))
[docs] def select_wavelength(self, wavelength): ret, recommended_delay_ms = self._client.request32('select_wavelength', wavelength) self.errcheck(ret, wavelength) return recommended_delay_ms
[docs] def set(self, hw_id, token, index, value): ret = self._client.request32('set', hw_id, token, index, value) return self.errcheck(ret, hw_id, token, index, value)
[docs] def version(self): """:class:`str`: The version number of the SDK.""" version = self._client.request32('get_version') self.log_debug('%s.version() -> %s', self.__class__.__name__, version) return version
[docs] def zero_calibration(self, start_wavelength, stop_wavelength): ret = self._client.request32('zero_calibration', start_wavelength, stop_wavelength) return self.errcheck(ret, start_wavelength, stop_wavelength)