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

mmcbrs232/mdcliapi.py

@@ -0,0 +1,110 @@
+"""Majordomo Protocol Client API, Python version.
+
+Implements the MDP/Worker spec at http:#rfc.zeromq.org/spec:7.
+
+Author: Min RK <benjaminrk@gmail.com>
+Based on Java example by Arkadiusz Orzechowski
+"""
+
+import logging
+
+import zmq
+
+from mmcbrs232 import MDP
+from mmcbrs232 import zhelpers
+
+class MajorDomoClient(object):
+    """Majordomo Protocol Client API, Python version.
+
+      Implements the MDP/Worker spec at http:#rfc.zeromq.org/spec:7.
+    """
+    broker = None
+    ctx = None
+    client = None
+    poller = None
+    # ms
+    timeout = 20000
+    retries = 5
+    verbose = False
+
+    def __init__(self, broker, verbose=False):
+        self.broker = broker
+        self.verbose = verbose
+        self.ctx = zmq.Context()
+        self.poller = zmq.Poller()
+        logging.basicConfig(format="%(asctime)s %(message)s", datefmt="%Y-%m-%d %H:%M:%S",
+                level=logging.INFO)
+        self.reconnect_to_broker()
+
+
+    def reconnect_to_broker(self):
+        """Connect or reconnect to broker"""
+        if self.client:
+            self.poller.unregister(self.client)
+            self.client.close()
+        self.client = self.ctx.socket(zmq.REQ)
+
+        self.client.setsockopt(zmq.SNDHWM, 1000)
+        self.client.setsockopt(zmq.SNDBUF, 1000)
+        self.client.setsockopt(zmq.RCVHWM, 1000)
+        self.client.setsockopt(zmq.RCVBUF, 1000)
+        self.client.set_hwm(10000)
+
+        self.client.linger = 0
+        self.client.connect(self.broker)
+        self.poller.register(self.client, zmq.POLLIN)
+        if self.verbose:
+            logging.info("I: connecting to broker at %s...", self.broker)
+
+    def send(self, service, request):
+        """Send request to broker and get reply by hook or crook.
+
+        Takes ownership of request message and destroys it when sent.
+        Returns the reply message or None if there was no reply.
+        """
+        if not isinstance(request, list):
+            request = [request]
+        request = [MDP.C_CLIENT, service] + request
+        if self.verbose:
+            logging.warn("I: send request to '%s' service: ", service)
+            zhelpers.dump(request)
+        reply = None
+
+        retries = self.retries
+        while retries > 0:
+            self.client.send_multipart(request)
+            try:
+                items = self.poller.poll(self.timeout)
+            except KeyboardInterrupt:
+                break # interrupted
+
+            if items:
+                msg = self.client.recv_multipart()
+                if self.verbose:
+                    logging.info("I: received reply:")
+                    zhelpers.dump(msg)
+
+                # Don't try to handle errors, just assert noisily
+                assert len(msg) >= 3
+
+                header = msg.pop(0)
+                assert MDP.C_CLIENT == header
+
+                reply_service = msg.pop(0)
+                assert service == reply_service
+
+                reply = msg
+                break
+            else:
+                if retries:
+                    logging.warn("W: no reply, reconnecting...")
+                    self.reconnect_to_broker()
+                else:
+                    logging.warn("W: permanent error, abandoning")
+                    break
+                retries -= 1
+
+        return reply
+
+    def destroy(self):
+        self.context.destroy()

mmcbrs232/mdclientlib.py

@@ -0,0 +1,266 @@
+#!/usr/bin/env python3
+"""
+Client library to help integrate the ZeroMQ serial port server into the PID
+test scripts.
+"""
+
+import contextlib
+import logging
+import platform
+
+try:
+    from importlib import metadata
+except (ImportError, ModuleNotFoundError):
+    try:
+        import importlib_metadata as metadata
+    except (ImportError, ModuleNotFoundError):
+        py_version = platform.python_version()
+        if py_version < '3.8':
+            logging.warning(
+                'Cannot import importlib, version information will NOT be available.'
+            )
+            logging.warning(
+                'Unsupported Python version (%s), upgrade to Python 3.8 or newer.',
+                py_version,
+            )
+        else:
+            logging.error('Cannot import importlib')
+
+from mmcbrs232 import mdcliapi
+from mmcbrs232 import common
+from mmcbrs232 import psuset
+from mmcbrs232 import psustat
+
+# read the package version number as originally specified in setup.py
+try:
+    __version__ = metadata.version('mmcb-rs232-avt')
+except NameError:
+    # end-user is probably using a Python version < 3.8
+    __version__ = 'unknown'
+
+
+###############################################################################
+# support
+###############################################################################
+
+
+def default():
+    """
+    ---------------------------------------------------------------------------
+    args : none
+    ---------------------------------------------------------------------------
+    returns : dict
+    ---------------------------------------------------------------------------
+    """
+    return {
+        'alias': None,
+        'channel': None,
+        'current_limit': None,
+        'debug': None,
+        'decimal_places': 2,
+        'forwardbias': False,
+        'immediate': False,
+        'manufacturer': None,
+        'model': None,
+        'on': None,
+        'peltier': False,
+        'port': None,
+        'quiet': False,
+        'rear': None,
+        'reset': False,
+        'serial': None,
+        'settlingtime': 0.5,
+        'verbose': None,
+        'voltage': None,
+        'voltspersecond': 10
+    }
+
+
+###############################################################################
+# data structures
+#
+# model command lines from the PID scripts
+###############################################################################
+
+
+class Rs232:
+    """
+    Handle serial port interactions
+    """
+
+    # read hardware configuration
+    psus = common.cache_read(['hvpsu', 'lvpsu', 'chiller'])
+    settings = default()
+    channels = common.ports_to_channels(settings, psus)
+    ports = sorted(psus)
+
+    # create client
+    client = mdcliapi.MajorDomoClient('tcp://localhost:5556', verbose=False)
+
+    ############################################################################
+    # support
+    ############################################################################
+
+    def _get_serial_port_name(self, command):
+        """
+        get serial port name from command (psuset, psustat, ult80)
+        """
+        local_psus = self.psus.copy()
+        local_channels = self.channels.copy()
+
+        cli = command.split(' ')[0].strip()
+
+        if cli == 'ult80':
+            # obtain from device cache since there are no channels for the ULT80
+            rval = [
+                serial_port_name
+                for serial_port_name, details in self.psus.items()
+                if details[1] == 'chiller'
+            ][0]
+
+        elif cli == 'psuset':
+            settings = default()
+            psuset.check_arguments(settings, command)
+            single = common.unique(settings, local_psus, local_channels)
+
+            rval = next(iter(local_psus)) if single else None
+
+        elif cli == 'psustat':
+            settings = {
+                'alias': None,
+                'channel': None,
+                'manufacturer': None,
+                'model': None,
+                'port': None,
+                'serial': None,
+                'time': None,
+            }
+            psustat.check_arguments(settings, command)
+            single = common.unique(settings, local_psus, local_channels)
+
+            if settings['filter'] and not single:
+                rval = None
+            else:
+                rval = next(iter(local_psus))
+        else:
+            rval = None
+
+        return rval
+
+    def _issue_serial_command(self, command):
+        """
+        """
+        serial_port_name = self._get_serial_port_name(command)
+        reply = None
+        if serial_port_name is None:
+            return reply
+
+        request = bytes(command, encoding='utf-8')
+
+        with contextlib.suppress(KeyboardInterrupt):
+            reply = self.client.send(
+                bytes(serial_port_name, encoding='utf-8'), request
+            )
+
+        return reply
+
+    @staticmethod
+    def _reply_value(reply):
+        """
+        Extract value from returned string; discard latency figure.
+
+        ------------------------------------------------------------------------
+        args
+            reply : list of str
+                e.g. [b'ult80 -i : None (1.008616 s)']
+        ------------------------------------------------------------------------
+        returns : float, bool or None
+        ------------------------------------------------------------------------
+        """
+        value_str, *_ = reply[0].decode().partition(':')[-1].partition('(')
+
+        try:
+            value = float(value_str)
+        except ValueError:
+            value = {'True': True, 'False': False}.get(value_str.strip())
+
+        return value
+
+
+    ############################################################################
+    # obtain readings
+    ############################################################################
+
+    def get_ult80_temps(self):
+        """
+        ------------------------------------------------------------------------
+        args : none
+        ------------------------------------------------------------------------
+        returns : float, float
+            (internal_temperature, set point)
+        ------------------------------------------------------------------------
+        """
+        return (
+            self._reply_value(self._issue_serial_command('ult80 -r')),
+            self._reply_value(self._issue_serial_command('ult80 -i')),
+        )
+
+    def get_pt_v(self, psu_id, channel):
+        """
+        HMP4040 set voltage
+        """
+        return self._reply_value(
+            self._issue_serial_command(
+                f'psustat --model hmp4040 --channel {channel} --serial {psu_id} --sv'
+            )
+        )
+
+    def get_pt_i(self, psu_id, channel):
+        """
+        HMP4040 measured current
+        """
+        return self._reply_value(
+            self._issue_serial_command(
+                f'psustat --model hmp4040 --channel {channel} --serial {psu_id} --mi'
+            )
+        )
+
+    def get_pt_sv_fast(self, psu_id, channel):
+        """
+        HMP4040 get channel set voltage, tailored for ZeroMQ serial port server.
+        """
+        return self._reply_value(
+            self._issue_serial_command(
+                f'psustat --model hmp4040 --channel {channel} --serial {psu_id} --sv --zserv'
+            )
+        )
+
+    def get_pt_mi_fast(self, psu_id, channel):
+        """
+        HMP4040 get channel measured current, tailored for ZeroMQ serial port server.
+        """
+        return self._reply_value(
+            self._issue_serial_command(
+                f'psustat --model hmp4040 --channel {channel} --serial {psu_id} --mi --zserv'
+            )
+        )
+
+    def psu_set(self, psu_id, channel, voltage, current):
+        """
+        channel on
+        """
+        return self._reply_value(
+            self._issue_serial_command(
+                f'psuset {voltage} --limit {current} --on --channel {channel} --serial {psu_id}'
+            )
+        )
+
+    def psu_unset(self, psu_id, channel, voltage, current):
+        """
+        channel off
+        """
+        return self._reply_value(
+            self._issue_serial_command(
+                f'psuset {voltage} --limit {current} --off --channel {channel} --serial {psu_id}'
+            )
+        )

mmcbrs232/mdwrkapi.py

@@ -0,0 +1,183 @@
+"""Majordomo Protocol Worker API, Python version
+
+Implements the MDP/Worker spec at http:#rfc.zeromq.org/spec:7.
+
+Author: Min RK <benjaminrk@gmail.com>
+Based on Java example by Arkadiusz Orzechowski
+"""
+
+import logging
+import time
+import zmq
+
+from mmcbrs232 import MDP
+from mmcbrs232 import zhelpers
+
+class MajorDomoWorker(object):
+    """Majordomo Protocol Worker API, Python version
+
+    Implements the MDP/Worker spec at http:#rfc.zeromq.org/spec:7.
+    """
+
+    # HEARTBEAT_LIVENESS = 3 # 3-5 is reasonable
+    HEARTBEAT_LIVENESS = 5 # 3-5 is reasonable
+
+    broker = None
+    ctx = None
+    service = None
+
+    worker = None # Socket to broker
+    heartbeat_at = 0 # When to send HEARTBEAT (relative to time.time(), so in seconds)
+    liveness = 0 # How many attempts left
+    heartbeat = 2500 # Heartbeat delay, msecs
+    reconnect = 2500 # Reconnect delay, msecs
+    # heartbeat = 5000 # Heartbeat delay, msecs
+    # reconnect = 5000 # Reconnect delay, msecs
+
+    # Internal state
+    expect_reply = False # False only at start
+
+    # timeout = 2500 # poller timeout
+    timeout = 5000 # poller timeout
+
+    verbose = False # Print activity to stdout
+
+    # Return address, if any
+    reply_to = None
+
+    def __init__(self, broker, service, verbose=False):
+        self.broker = broker
+        self.service = service
+        self.verbose = verbose
+        self.ctx = zmq.Context()
+        self.poller = zmq.Poller()
+        logging.basicConfig(format="%(asctime)s %(message)s",
+                            datefmt="%Y-%m-%d %H:%M:%S",
+                            level=logging.INFO)
+        self.reconnect_to_broker()
+
+
+    def reconnect_to_broker(self):
+        """Connect or reconnect to broker"""
+        if self.worker:
+            self.poller.unregister(self.worker)
+            self.worker.close()
+        self.worker = self.ctx.socket(zmq.DEALER)
+
+        self.worker.setsockopt(zmq.SNDHWM, 1000)
+        self.worker.setsockopt(zmq.SNDBUF, 1000)
+        self.worker.setsockopt(zmq.RCVHWM, 1000)
+        self.worker.setsockopt(zmq.RCVBUF, 1000)
+        self.worker.set_hwm(10000)
+
+        self.worker.linger = 0
+        self.worker.connect(self.broker)
+        self.poller.register(self.worker, zmq.POLLIN)
+        if self.verbose:
+            logging.info("I: connecting to broker at %s...", self.broker)
+
+        # Register service with broker
+        self.send_to_broker(MDP.W_READY, self.service, [])
+
+        # If liveness hits zero, queue is considered disconnected
+        self.liveness = self.HEARTBEAT_LIVENESS
+        self.heartbeat_at = time.time() + 1e-3 * self.heartbeat
+
+
+    def send_to_broker(self, command, option=None, msg=None):
+        """Send message to broker.
+
+        If no msg is provided, creates one internally
+        """
+        if msg is None:
+            msg = []
+        elif not isinstance(msg, list):
+            msg = [msg]
+
+        if option:
+            msg = [option] + msg
+
+        msg = [b'', MDP.W_WORKER, command] + msg
+        if self.verbose:
+            logging.info("I: sending %s to broker", command)
+            zhelpers.dump(msg)
+        self.worker.send_multipart(msg)
+
+
+    def recv(self, reply=None):
+        """Send reply, if any, to broker and wait for next request."""
+        # Format and send the reply if we were provided one
+        assert reply is not None or not self.expect_reply
+
+        if reply is not None:
+            assert self.reply_to is not None
+            reply = [self.reply_to, b''] + reply
+            self.send_to_broker(MDP.W_REPLY, msg=reply)
+
+        self.expect_reply = True
+
+        while True:
+            # Poll socket for a reply, with timeout
+            try:
+                items = self.poller.poll(self.timeout)
+            except KeyboardInterrupt:
+                break # Interrupted
+
+            if items:
+                msg = self.worker.recv_multipart()
+                if self.verbose:
+                    logging.info("I: received message from broker: ")
+                    zhelpers.dump(msg)
+
+                self.liveness = self.HEARTBEAT_LIVENESS
+                # Don't try to handle errors, just assert noisily
+                assert len(msg) >= 3
+
+                empty = msg.pop(0)
+                assert empty == b''
+
+                header = msg.pop(0)
+                assert header == MDP.W_WORKER
+
+                command = msg.pop(0)
+                if command == MDP.W_REQUEST:
+                    # We should pop and save as many addresses as there are
+                    # up to a null part, but for now, just save one...
+                    self.reply_to = msg.pop(0)
+                    # pop empty
+                    empty = msg.pop(0)
+                    assert empty == b''
+
+                    return msg # We have a request to process
+                elif command == MDP.W_HEARTBEAT:
+                    # Do nothing for heartbeats
+                    pass
+                elif command == MDP.W_DISCONNECT:
+                    self.reconnect_to_broker()
+                else :
+                    logging.error("E: invalid input message: ")
+                    zhelpers.dump(msg)
+
+            else:
+                self.liveness -= 1
+                if self.liveness == 0:
+                    if self.verbose:
+                        logging.warn("W: disconnected from broker - retrying...")
+                    try:
+                        time.sleep(1e-3*self.reconnect)
+                    except KeyboardInterrupt:
+                        break
+                    self.reconnect_to_broker()
+
+            # Send HEARTBEAT if it's time
+            if time.time() > self.heartbeat_at:
+                self.send_to_broker(MDP.W_HEARTBEAT)
+                self.heartbeat_at = time.time() + 1e-3*self.heartbeat
+
+        logging.warn("W: interrupt received, killing worker...")
+        return None
+
+
+    def destroy(self):
+        # context.destroy depends on pyzmq >= 2.1.10
+        self.ctx.destroy(0)