mmcb-rs232-avt 1.0.20__py3-none-any.whl → 1.1.37__py3-none-any.whl

mmcbrs232/dmm.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+"""
+Read values from the Keithley DMM6500.
+"""
+
+import argparse
+import fcntl
+import itertools
+import sys
+import time
+
+from mmcbrs232 import common
+from mmcbrs232 import dmm_interface
+
+
+##############################################################################
+# command line option handler
+##############################################################################
+
+
+def check_arguments():
+    """
+    handle command line options
+
+    --------------------------------------------------------------------------
+    args : none
+    --------------------------------------------------------------------------
+    returns
+        args : int, <class 'argparse.Namespace'>
+    --------------------------------------------------------------------------
+    """
+    parser = argparse.ArgumentParser(
+        description='Reads voltage or current from the Keithley DMM6500.'
+    )
+
+    parser.add_argument(
+        'channel', nargs='?', metavar='channel',
+        help=(
+            'Select measurement channel. '
+            'For use with the 2001-SCAN card.'
+        ),
+        choices=range(1, 11),
+        type=int, default=None)
+
+    parser.add_argument(
+        '-p', '--plain',
+        action='store_true',
+        help='print the requested figure only (deprecated: use -q instead)')
+    parser.add_argument(
+        '-q', '--quiet',
+        action='store_true',
+        help='print the requested figure only')
+    parser.add_argument(
+        '-c', '--capacitance',
+        action='store_true',
+        help='Read capacitance (F)')
+    parser.add_argument(
+        '--currentac',
+        action='store_true',
+        help='Read AC current (A)')
+    parser.add_argument(
+        '-i', '--currentdc',
+        action='store_true',
+        help='Read DC current (A)')
+    parser.add_argument(
+        '-r', '--resistance',
+        action='store_true',
+        help='Read two-wire resistance (\u03a9)')
+    parser.add_argument(
+        '-t', '--temperature',
+        action='store_true',
+        help='Read temperature (\u00b0C)')
+    parser.add_argument(
+        '--voltageac',
+        action='store_true',
+        help='Read AC voltage (V)')
+    parser.add_argument(
+        '-v', '--voltagedc',
+        action='store_true',
+        help='Read DC voltage (V)')
+
+    args = parser.parse_args()
+
+    channel = args.channel
+    del args.channel
+
+    return channel, args
+
+
+##############################################################################
+# serial port identification
+##############################################################################
+
+
+def port_name():
+    """
+    Get the port name from the cache ASSUMING that there's only one instrument
+    in the test environment.
+
+    --------------------------------------------------------------------------
+    args : none
+    --------------------------------------------------------------------------
+    returns : string or None
+        e.g. '/dev/ttyUSB0'
+    --------------------------------------------------------------------------
+    """
+    _cached_instruments = common.cache_read({'instrument'})
+
+    _channels = []
+    for _port, _details in _cached_instruments.items():
+        (
+            _config,
+            _device_type,
+            _serial_number,
+            _model,
+            _manufacturer,
+            _device_channels,
+            _release_delay,
+        ) = _details
+
+        for _device_channel in _device_channels:
+            _channels.append(
+                common.Channel(
+                    _port,
+                    _config,
+                    _serial_number,
+                    _model,
+                    _manufacturer,
+                    _device_channel,
+                    _device_type,
+                    _release_delay,
+                    None,
+                )
+            )
+
+    try:
+        _channel = _channels[0]
+    except IndexError:
+        return None
+
+    return _channel.port
+
+
+##############################################################################
+# main
+##############################################################################
+
+
+def main():
+    """ Read values from the Keithley DMM6500 """
+
+    channel, args = check_arguments()
+
+    with open(common.RS232_LOCK_GLOBAL, 'a') as lock_file:
+
+        # acquire the RS232 global lock
+        fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX)
+
+        # --------------------------------------------------------------------
+
+        dmm = dmm_interface.Dmm6500()
+        if dmm.init_failed:
+            print('could not initialise serial port')
+            return 3
+
+        if channel is not None:
+            # isolate all relays
+            dmm.mux_open_all_channels()
+            # enable relay for given channel
+            dmm.mux_close_channel(channel)
+
+        configure = {
+                'capacitance': dmm.configure_read_capacitance,
+                'currentac': dmm.configure_read_ac_current,
+                'currentdc': dmm.configure_read_dc_current,
+                'resistance': dmm.configure_read_resistance,
+                'temperature': dmm.configure_read_temperature,
+                'voltagedc': dmm.configure_read_dc_voltage,
+                'voltageac': dmm.configure_read_ac_voltage,
+        }
+
+        # AC quantities sometimes return None on the first attempt
+        retries = 3
+
+        success = []
+
+        for function, required in vars(args).items():
+            if not required or function == 'plain' or function == 'quiet':
+                continue
+
+            configure[function]()
+
+            value = None
+            for _ in itertools.repeat(None, retries):
+                value = dmm.read_value()
+                if value is not None:
+                    success.append(True)
+                    break
+                time.sleep(0.1)
+
+            if args.plain or args.quiet:
+                print(value)
+            else:
+                print(f'{function}, {common.si_prefix(value)}, {value}')
+
+        if channel is not None:
+            # isolate relay
+            dmm.mux_open_channel(channel)
+
+        # --------------------------------------------------------------------
+
+        # release the RS232 global lock
+        fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
+
+    return 0 if any(success) else 3
+
+
+##############################################################################
+if __name__ == '__main__':
+    sys.exit(main())

{mmcb_rs232 → mmcbrs232}/dmm_interface.py

@@ -9,8 +9,8 @@ import weakref
 
 import serial
 
-from mmcb_rs232 import common
-from mmcb_rs232 import lexicon
+from mmcbrs232 import common
+from mmcbrs232 import lexicon
 
 
 class Production:
@@ -96,7 +96,7 @@ class Dmm6500:
         """check (indirectly) if the serial port has been closed"""
         return not self._finalizer.alive
 
-    def _send_command(self, command):
+    def _send_command(self, command, argument1=None):
         """
         Issue command to instrument.
 
@@ -111,7 +111,7 @@ class Dmm6500:
             self._pipeline,
             self._ser,
             self._channel,
-            lexicon.instrument(self._channel.model, command),
+            lexicon.instrument(self._channel.model, command, argument1),
         )
 
     def configure_read_capacitance(self):
@@ -160,3 +160,24 @@ class Dmm6500:
             value = None
 
         return value
+
+    def mux_close_channel(self, channel):
+        """
+        Close channel (switch mux relay output to rear terminals; relay on).
+        For use with the 2001-SCAN card.
+        """
+        self._send_command('mux_close_channel', channel)
+
+    def mux_open_channel(self, channel):
+        """
+        Open channel (isolate relay from rear terminals).
+        For use with the 2001-SCAN card.
+        """
+        self._send_command('mux_open_channel', channel)
+
+    def mux_open_all_channels(self):
+        """
+        Open all channels (isolate all relays from rear terminals).
+        For use with the 2001-SCAN card.
+        """
+        self._send_command('mux_open_all_channels')

{mmcb_rs232 → mmcbrs232}/iv.py

@@ -25,6 +25,7 @@ import contextlib
 import csv
 import ctypes
 import datetime
+import fcntl
 import functools
 import itertools
 import logging
@@ -54,9 +55,9 @@ from yoctopuce import yocto_api as yapi
 from yoctopuce import yocto_temperature as ytemp
 from yoctopuce import yocto_humidity as yhumi
 
-from mmcb_rs232 import common
-from mmcb_rs232 import lexicon
-from mmcb_rs232 import sequence
+from mmcbrs232 import common
+from mmcbrs232 import lexicon
+from mmcbrs232 import sequence
 
 
 ##############################################################################
@@ -994,7 +995,7 @@ def sense(pipeline, zmq_skt, settings):
     pi@raspberrypi:~/dev/1d-phantom/utilities $ sudo netstat -ltnp
     Active Internet connections (only servers)
     Proto Recv-Q Send-Q Local Address Foreign Address State  PID/Program name
-    tcp        0      0 0.0.0.0:5556  0.0.0.0:*       LISTEN 32539/python3
+    tcp        0      0 0.0.0.0:5566  0.0.0.0:*       LISTEN 32539/python3
     tcp        0      0 0.0.0.0:22    0.0.0.0:*       LISTEN 776/sshd
     tcp        0      0 127.0.0.1:631 0.0.0.0:*       LISTEN 27597/cupsd
     tcp        0      0 127.0.0.1:25  0.0.0.0:*       LISTEN 992/exim4
@@ -1030,7 +1031,7 @@ def sense(pipeline, zmq_skt, settings):
     """
     # configure communication with sense.py
     # Use REP/REQ (with handshaking) instead of PUB/SUB to avoid packet loss
-    port = 5556
+    port = 5566
     try:
         zmq_skt.bind(f'tcp://*:{port}')
     except zmq.error.ZMQError as zerr:
@@ -2775,7 +2776,19 @@ def main():
     # Check status of outputs and interlock (inhibit) on all power supplies
     ##########################################################################
 
-    common.initial_power_supply_check(settings, pipeline, psus, channels)
+    with open(common.RS232_LOCK_GLOBAL, 'a') as lock_file:
+
+        # acquire the RS232 global lock
+        fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX)
+
+        # --------------------------------------------------------------------
+
+        common.initial_power_supply_check(settings, pipeline, psus, channels)
+
+        # --------------------------------------------------------------------
+
+        # release the RS232 global lock
+        fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
 
     ##########################################################################
     # detect presence of temperature and humidity sensors
@@ -2820,10 +2833,23 @@ def main():
 
     _gidfp_pf = functools.partial(get_iv_data_from_psu, settings=settings,
                                   pipeline=pipeline, graceful_quit=graceful_quit)
-    with cf.ThreadPoolExecutor() as executor:
-        board_iv = (executor.submit(_gidfp_pf, channel) for channel in channels)
-        for future in cf.as_completed(board_iv):
-            consignment.packets.append(future.result())
+
+    with open(common.RS232_LOCK_GLOBAL, 'a') as lock_file:
+
+        # acquire the RS232 global lock
+        fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX)
+
+        # --------------------------------------------------------------------
+
+        with cf.ThreadPoolExecutor() as executor:
+            board_iv = (executor.submit(_gidfp_pf, channel) for channel in channels)
+            for future in cf.as_completed(board_iv):
+                consignment.packets.append(future.result())
+
+        # --------------------------------------------------------------------
+
+        # release the RS232 global lock
+        fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
 
     ##########################################################################
     # release resources for YoctoPuce API and threads

{mmcb_rs232 → mmcbrs232}/lexicon.py

@@ -563,6 +563,18 @@ def instrument(model, command, argument1=None, argument2=None):
         'identify': '*IDN?',
         'read value': 'print(dmm.measure.read())',
         'reset': 'dmm.reset()',
+
+        # --------------------------------------------------------------------
+        # multiplexer 2001-SCAN expansion card
+        # --------------------------------------------------------------------
+
+        'mux_close_channel': f'channel.close("{argument1}")',
+        'mux_close_all_channels': 'channel.close("1,2,3,4,5,6,7,8,9,10")',
+        'mux_open_channel': f'channel.open("{argument1}")',
+        'mux_open_all_channels': 'channel.open("1,2,3,4,5,6,7,8,9,10")',
+
+        # this should return '[1]=0' (channel open) or '[1]=channel.IND_CLOSED'
+        'read channel getstate': f'print(channel.getstate("{argument1}"))',
     }
 
     instructions = {