cgse 2023.38.0__py3-none-any.whl → 2024.1.4__py3-none-any.whl

egse/tdms.py

@@ -1,171 +0,0 @@
-"""
-This module provides functions to load and parse Labview TDMS files.
-
-The text representation of a TDMS file is sent over a TCP/IP socket from the TCS EGSE to the Common-EGSE control
-server. The format of the text string is as follows:
-
-There are four groups of data: (1) the start time, (2) the time interval of the sampling, i.e. delta time,
-(3) the parameter names, and (4) the actual sampled data. There is a blank line between each group. Each line
-contains a lot of trailing whitespace in the form of a TAB character, '\\t'.
-
-    start time:
-    12/04/2019 17:38:27.584141
-
-    dt:
-    0.1
-
-    channel names:
-    Ch1_name    Ch2_name    Ch3_name
-
-    data:
-    0.1 0.2 0.3
-    0.2 0.3 0.1
-    0.3 0.1 0.2
-
-A full description of the TDMS text file format is given in the TCS EGSE ICD [PTO-AST-PL-TCGSE-ICD-0012].
-"""
-import datetime
-import io
-import logging
-from typing import Union
-
-import numpy as np
-
-from collections import namedtuple
-from pathlib import Path
-
-from egse.config import find_file
-from egse.system import Timer
-
-logging.basicConfig(level=logging.DEBUG)
-LOGGER = logging.getLogger(__name__)
-
-
-def load_tdms_from_string(data_string: str):
-    """
-    Loads and parses a string representation of a Labview TDMS file. This function calls `load_tdms_from_stream()`.
-    See the latter function for documentation on the return value.
-
-    Args:
-        data_string: a string containing the TDMS data
-
-    Returns:
-        a namedtuple with fields ['start_time', 'time_interval', 'names', 'values', 'time'].
-
-    Raises:
-        ValueError: when an input error is detected, e.g. incorrect file format or filename is None
-
-    """
-    with io.StringIO(data_string) as tdms:
-        data = load_tdms_from_stream(tdms)
-
-    return data
-
-
-def load_tdms_from_file(filename: Union[str, Path]):
-    """
-    Loads and parses a text file representation of a Labview TDMS file. This function calls `load_tdms_from_stream()`.
-    See the latter function for documentation on the return value.
-
-    Args:
-        filename: the full path name of the file
-
-    Returns:
-        a namedtuple with fields ['start_time', 'time_interval', 'names', 'values', 'time'].
-
-    Raises:
-        ValueError: when an input error is detected, e.g. incorrect file format or filename is None
-        FileNotFoundError: when a given filename doesn't exist
-
-    """
-    if filename is None:
-        raise ValueError("No filename was given or filename is None.")
-
-    with Path(filename).open(mode='r') as tdms:
-        data = load_tdms_from_stream(tdms)
-
-    return data
-
-
-def load_tdms_from_stream(stream):
-    """
-    Loads and parses a text representation of a Labview TDMS file. The format of the file is fixed and is
-    described at the module level docstring.
-
-    The stream is parsed and returned as a namedtuple which contains the following fields:
-
-    * **start_time**: a `datetime` object that contains the start time of the sampling period [datetime]
-    * **time_interval**: the sampling time interval [s]
-    * **names**: a list of parameter names, one for each column in values [str]
-    * **values**: a two-dimensional numpy array containing the samples. The shape is (number of names,
-    number of samples) [float]
-    * **time**: a numpy array with the sampling times for the values [datetime]
-
-    Args:
-        stream: a stream that supports the io protocol for readline() and readlines().
-
-    Returns:
-        a namedtuple with fields ['start_time', 'time_interval', 'names', 'values', 'time'].
-
-    Raises:
-        ValueError: when an input error is detected, e.g. incorrect file format or filename is None
-
-    """
-
-    MAX_LINE_LENGTH = 80
-
-    # The first line in the file shall be the starting time of the sample
-
-    line = stream.readline()
-    if line.startswith('start time:'):
-        line = stream.readline().rstrip()
-        start_time = line.split('\t')[0]
-        start_time = datetime.datetime.strptime(start_time, '%m/%d/%Y %H:%M:%S.%f')
-    else:
-        raise ValueError(
-            f"TDMS Error: expected start time as the first line, got {line[:MAX_LINE_LENGTH]}.")
-
-    # The next line shall be the time interval 'dt' as a float
-
-    stream.readline()  # skip the empty line
-    line = stream.readline()
-    if line.startswith('dt:'):
-        line = stream.readline().rstrip()
-        time_interval = float(line.split('\t')[0])
-    else:
-        raise ValueError(f"TDMS Error: expected 'dt:', got {line[:MAX_LINE_LENGTH]}.")
-
-    # The next line contains the channel names
-
-    stream.readline()  # skip the empty line
-    line = stream.readline()
-    if line.startswith('channel names:'):
-        line = stream.readline().rstrip()
-        names = line.split('\t')
-        keys = [name for name in names]
-        data = [[] for _ in names]
-    else:
-        raise ValueError(f"TDMS Error: expected 'channel names:', got {line[:MAX_LINE_LENGTH]}.")
-
-    # The next lines contain the data
-
-    stream.readline()  # skip the empty line
-    line = stream.readline()
-    if line.startswith('data:'):
-        lines = stream.readlines()  # this should read the rest of the file
-        for line in lines:
-            values = line.rstrip().split('\t')
-            for idx, value in enumerate(values):
-                data[idx].append(float(value))
-    else:
-        raise ValueError(f"TDMS Error: expected 'data:', got {line[:MAX_LINE_LENGTH]}.")
-
-    time_serie = np.array(
-        [start_time + datetime.timedelta(seconds=x*time_interval) for x in range(len(lines))]
-    )
-
-    # Make a data structure out of this, i.e. a named tuple
-
-    tdms = namedtuple('TDMS', ['start_time', 'time_interval', 'names', 'values', 'time'])
-
-    return tdms(start_time=start_time, time_interval=time_interval, names=keys, values=np.array(data), time=time_serie)

egse/tempcontrol/__init__.py

@@ -1,23 +0,0 @@
-"""
-This package provides services for different kinds of temperature controllers.
-
-The current on-going work is for support of the following devices:
-
-* Keithley DAQ6510
-* LakeShore Model 336
-* National Instruments
-* SRS PTC10 temperature regulator
-
-"""
-class TempError(Exception):
-    pass
-
-# The __pdoc__ dict is understood by pdoc3 and instructs to exclude the 'keys' from the documentation.
-# See: https://pdoc3.github.io/pdoc/doc/pdoc/#overriding-docstrings-with-__pdoc__
-
-# The following modules are excluded because they assume the gssw package is installed (SRON specific)
-
-__pdoc__ = {
-    'beaglebone': False,
-    'spid': False,
-}

egse/tempcontrol/agilent/agilent34970.py

@@ -1,109 +0,0 @@
-import logging
-
-from egse.proxy import Proxy
-from egse.decorators import dynamic_interface
-from egse.device import DeviceInterface
-from egse.settings import Settings
-from egse.tempcontrol.agilent.agilent34970_devif import Agilent34970Error
-from egse.tempcontrol.agilent.agilent34970_devif import Agilent34970DeviceInterface
-from egse.zmq_ser import connect_address
-
-logger = logging.getLogger(__name__)
-
-DEVICE_SETTINGS = Settings.load(filename='agilent34970.yaml')
-CTRL_SETTINGS = Settings.load("Agilent 34970 Control Server")
-
-class Agilent34970Interface(DeviceInterface):
-    """ Agilent 34970 base class."""
-
-    @dynamic_interface
-    def get_idn(self):
-        """ Get Agilent34970 IDN message. """
-        return NotImplemented
-
-    @dynamic_interface
-    def read_resistance_temperature(self):
-        """ Measure 4-wire resistance. """
-        return NotImplemented
-
-    @dynamic_interface
-    def trigger_scan(self):
-        return NotImplemented
-
-class Agilent34970Simulator(Agilent34970Interface):
-
-    def __init__(self):
-        self._is_connected = True
-
-    def is_connected(self):
-       return self._is_connected
-
-    def is_simulator(self):
-       return True
-
-    def connect(self):
-       self._is_connected = True
-
-    def disconnect(self):
-       self._is_connected = False
-
-    def reconnect(self):
-       if self.is_connected():
-           self.disconnect()
-       self.connect()
-
-    def get_idn(self, dev_idx):
-       return 'Agilent34970'
-
-
-    def read_resistance_temperature(self):
-        return [0, 0, 0, 0], [0, 0, 0, 0]
-
-    def trigger_scan(self):
-        pass
-
-class Agilent34970Controller(Agilent34970Interface):
-
-    def __init__(self, device_index):
-        super().__init__()
-
-        logger.debug('Initalizing Agilent34970 Controller')
-
-        try:
-            self.agilent = Agilent34970DeviceInterface(device_index)
-        except Agilent34970Error as exc:
-            logger.warning(f"Agilent34970Error caught: Couldn't establish connectin ({exc})")
-            raise Agilent34970Error(
-                "Couldn't establish a connection with Agilent34970 controller."
-            ) from exc
-
-    def is_simulator(self):
-        return False
-
-    def is_connected(self):
-        return self.agilent.is_connected()
-
-    def connect(self):
-        if not self.agilent.is_connected():
-            self.agilent.connect()
-
-    def disconnect(self):
-        self.agilent.disconnect()
-
-    def reconnect(self):
-        self.agilent.reconnect()
-
-    def get_idn(self):
-        return self.agilent.get_idn()
-
-    def read_resistance_temperature(self):
-        return self.agilent.read_resistance_temperature()
-
-    def trigger_scan(self):
-        return self.agilent.trigger_scan()
-
-class Agilent34970Proxy(Proxy, Agilent34970Interface):
-    def __init__(self, agilent_index: int):
-        self.name = "DAQ"+str(agilent_index)
-
-        super().__init__(connect_address(CTRL_SETTINGS.PROTOCOL, CTRL_SETTINGS.HOSTNAME, CTRL_SETTINGS[self.name]["COMMANDING_PORT"]), timeout=20000)

egse/tempcontrol/agilent/agilent34970.yaml

@@ -1,44 +0,0 @@
-BaseClass:
-    egse.tempcontrol.agilent.Agilent34970Interface
-
-ProxyClass:
-    egse.tempcontrol.agilent.Agilent34970Proxy
-
-ControlServerClass:
-    egse.tempcontrol.agilent.Agilent34972ControlServer
-
-ControlServer:
-    egse.tempcontrol.agilent.agilent34970_cs
-
-Commands:
-    # The command strings in this file are not used.
-    # They need to include the arguments of the commands though or else the control server will
-    # remove them from the interface.
-
-    disconnect:
-        description: Disconnect from the Agilent34970 Controller.
-
-    connect:
-        description: Connect to the Agilent34970 Controller.
-
-    reconnect:
-        description: Reconnect to the Agilent34970 Controller.
-
-    is_simulator:
-        description: Ask if the control server is a simulator.
-        returns:     bool | True if far end is a simulator.
-
-    is_connected:
-        description: Check if Agilent34970 Controller is connected.
-
-    # Definition of the device commands.
-    get_idn:
-        description: Get device IDN message.
-        returns:     str
-
-    read_resistance_temperature:
-        description: Measure temperatures for all channels in the scan list
-        returns:     tuple(list(float), list(float)) | tuple of lists of resistance and temperature values
-
-    trigger_scan:
-        description: Perform a scan of the specified channels

egse/tempcontrol/agilent/agilent34970_cs.py

@@ -1,116 +0,0 @@
-#!/usr/bin/env python3
-import argparse
-import logging
-import sys
-import click
-
-import zmq
-from prometheus_client import start_http_server
-
-import multiprocessing
-multiprocessing.current_process().name = "agilent34970_cs"
-
-from egse.control import ControlServer
-from egse.settings import Settings
-from egse.zmq_ser import connect_address
-from egse.tempcontrol.agilent.agilent34970 import Agilent34970Interface, Agilent34970Proxy
-from egse.tempcontrol.agilent.agilent34970_protocol import Agilent34970Protocol
-
-logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-
-logger = logging.getLogger('__name__')
-
-CTRL_SETTINGS = Settings.load("Agilent 34970 Control Server")
-
-
-class Agilent34970ControlServer(ControlServer):
-
-    def __init__(self, index):
-        self.index = index
-        self.name = "DAQ"+str(index)
-        super().__init__()
-
-        self.device_protocol = Agilent34970Protocol(self, self.index)
-
-        logger.debug(f'Binding ZeroMQ socket to {self.device_protocol.get_bind_address()}')
-
-        self.device_protocol.bind(self.dev_ctrl_cmd_sock)
-
-        self.poller.register(self.dev_ctrl_cmd_sock, zmq.POLLIN)
-
-        self.set_hk_delay(CTRL_SETTINGS.DELAY)
-
-    def get_communication_protocol(self):
-        return CTRL_SETTINGS.PROTOCOL
-
-    def get_commanding_port(self):
-        return CTRL_SETTINGS[self.name]['COMMANDING_PORT']
-
-    def get_service_port(self):
-        return CTRL_SETTINGS[self.name]['SERVICE_PORT']
-
-    def get_monitoring_port(self):
-        return CTRL_SETTINGS[self.name]['MONITORING_PORT']
-
-    def get_storage_mnemonic(self):
-        try:
-            return CTRL_SETTINGS[self.name]['STORAGE_MNEMONIC']
-        except:
-            return f'Agilent34970_{self.index}'
-
-    def before_serve(self):
-        start_http_server(CTRL_SETTINGS[self.name]['METRICS_PORT'])
-
-
-@click.group()
-def cli():
-    pass
-
-
-@cli.command()
-@click.option("--simulator", "--sim", is_flag=True, help="Start the Agilent34970 Simulator as the backend.")
-@click.argument('index', type=click.IntRange(0, 1))
-def start(simulator, index):
-    """Start the BeagleBone Control Server."""
-
-    if simulator:
-        Settings.set_simulation_mode(True)
-    try:
-        logger.debug(f'Starting Agilent 34970 {index} Control Server')
-        
-        multiprocessing.current_process().name = f"agilent34970_cs_{index}"
-
-        control_server = Agilent34970ControlServer(index)
-        control_server.serve()
-
-    except KeyboardInterrupt:
-        logger.info("Shutdown requested...exiting")
-
-    except SystemExit as exit_code:
-        logger.info("System Exit with code {}.".format(exit_code))
-        sys.exit(exit_code)
-
-    except Exception:
-
-        logger.exception("Cannot start the Agilent Control Server")
-        # The above line does exactly the same as the traceback, but on the logger
-        # import traceback
-        # traceback.print_exc(file=sys.stdout)
-
-    return 0
-
-
-@cli.command()
-@click.argument('index', type=click.IntRange(0, 1))
-def stop(index):
-    """Send a 'quit_server' command to the Control Server."""
-
-    with Agilent34970Proxy(index) as proxy:
-
-        sp = proxy.get_service_proxy()
-        sp.quit_server()
-
-
-if __name__ == "__main__":
-
-    sys.exit(cli())

egse/tempcontrol/agilent/agilent34970_devif.py

@@ -1,182 +0,0 @@
-#!/usr/bin/env python3
-
-import logging
-import time
-
-from egse.command import ClientServerCommand
-from egse.exceptions import DeviceNotFoundError
-from egse.serialdevice import SerialDevice
-from egse.settings import Settings
-from egse.setup import get_setup
-
-logger = logging.getLogger(__name__)
-
-
-
-class Agilent34970Error(Exception):
-    pass
-
-
-class Agilent34970Command(ClientServerCommand):
-    def get_cmd_string(self, *args, **kwargs):
-        out = super().get_cmd_string(*args, **kwargs)
-        return out + '\n'
-
-
-class Agilent34970DeviceInterface(SerialDevice):
-
-    def __init__(self, device_index):
-
-        self._ctrl_settings = Settings.load(f'Agilent 34970 Controller')
-        self._setup = get_setup()
-        
-        self.device_index = device_index
-        
-        # Load device configuration from the common-egse global config file
-        self._port     = self._ctrl_settings[f"DAQ {device_index}"]["PORT"]
-        self._baudrate = self._ctrl_settings[f"DAQ {device_index}"]["BAUDRATE"]
-
-        self._setup = self._setup['gse'][f'agilent34970_{device_index}']
-        self._conversions = self._setup['conversion']
-
-        # Initialize the SerialDevice class with the port and baudrate
-        super().__init__(port=self._port, baudrate=self._baudrate, terminator='\n', timeout=15)
-        self.connect()
-        
-        self.create_scanlist()
-        self.configure_agilent()
-
-
-    def get_idn(self):
-        return self.query('*IDN?\n')
-
-    def format_scanlist(self, ch_list):
-        scanlist = '(@'
-        for idx, ch in enumerate(ch_list):
-            if idx == 0:
-                scanlist += f'{ch}'
-            elif idx < len(ch_list):
-                scanlist += f',{ch}'
-        scanlist += ')'
-        return scanlist
-    
-    def create_scanlist(self):
-        thermocouple = self._setup.thermocouples
-        two_wire = self._setup.two_wire
-        four_wire = self._setup.four_wire
-        pt100 = self._setup.pt100
-        
-        self.scanlist = thermocouple + two_wire + four_wire
-        self.scanlist.sort()
-        
-        self.thermocouple = thermocouple
-        self.two_wire = two_wire
-        self.four_wire = four_wire
-        self.pt100 = pt100
-    
-    def configure_agilent(self):
-        
-        # Extract configuration and scanlist from setup
-        scan_list = self.format_scanlist(self.scanlist) if self.scanlist != [] else [] 
-        thermocouple_list = self.format_scanlist(self.thermocouple) if self.thermocouple != [] else []
-        two_wire_list = self.format_scanlist(self.two_wire) if self.two_wire != [] else []
-        four_wire_list = self.format_scanlist(self.four_wire) if self.four_wire != [] else []
-        pt100_list = self.format_scanlist(self.pt100) if self.pt100 != [] else []
-
-        logger.info(f"Thermocouples: {thermocouple_list}")
-        logger.info(f"Two wire: {two_wire_list}")
-        logger.info(f"Four wire: {four_wire_list}")
-        logger.info(f"Pt100s: {pt100_list}")
-        logger.info(f"Final scanlist: {scan_list}")
-       
-        # Reset scan list
-        self.send_command("*RST\n")
-        
-        # Configure channels
-        if two_wire_list != []:
-            self.send_command(f"CONF:RES {two_wire_list}\n")
-            time.sleep(1)
-        if four_wire_list != []:
-            self.send_command(f"CONF:FRES {four_wire_list}\n")
-            time.sleep(1)
-        if thermocouple_list != []:
-            self.send_command(f"CONF:TEMP TC,T,{thermocouple_list}\n")
-            time.sleep(1)
-        if pt100_list != []:
-            self.send_command(f"CALC:SCAL:GAIN 10,{pt100_list}\n")
-            self.send_command(f'CALC:SCAL:STAT ON,{pt100_list}\n')
-            time.sleep(1)
-
-        # Save values with unit
-        self.send_command("FORM:READ:UNIT ON\n")
-        self.send_command("FORM:READ:CHAN ON\n")
-
-        
-        # Load scan list
-        self.send_command(f"ROUT:SCAN {scan_list}\n")
-        time.sleep(0.1)
-        
-        self.send_command(f'SENS:VOLT:DC:NPLC 10\n')
-        self.send_command('ROUT:CHAN:DEL 0.1\n')
-
-        self.send_command("INIT\n")
-        time.sleep(15)
-
-    def trigger_scan(self):
-        self.send_command("INIT\n")
-
-    def read_resistance_temperature(self):
-        # Fetch values stored in non-volatile memory
-        return_string = self.query(f"DATA:REMOVE? {len(self.scanlist)}\n")
-
-        # Check for errors
-        if len(return_string) == 0:
-            raise ConnectionError(f"No reply from device")
-
-        if return_string[-1] != '\n':
-            raise ConnectionError(f"Invalid termination character in response: {return_string}")
-        
-        values = return_string.split(',')
-        
-        resistances = {}
-        temperatures = {}
-
-        for i in range(0, len(values), 2):
-            value = values[i].split(' ')
-            channel = int(values[i+1])
-            if 'C' in value or 'C\r' in value:
-                resistances[f'{channel}'] = 0
-                temperatures[f'{channel}'] = float(value[0])          
-            elif 'OHM' in value or 'OHM\r' in value:
-                resistances[f'{channel}'] = abs(float(value[0]))
-                temperatures[f'{channel}'] = self._convert_resistance(abs(float(value[0])))  
-        
-        # Return values as list
-        return resistances, temperatures
-
-    def _convert_resistance(self, resistance):
-        return (  self._conversions[0]
-                + self._conversions[1] * resistance
-                + self._conversions[2] * resistance**2
-                + self._conversions[3] * resistance**3
-                + self._conversions[4] * resistance**4
-                + self._conversions[5] * resistance**5
-        )
-
-def main():
-
-    dev0 = Agilent34970DeviceInterface(0)
-    dev1 = Agilent34970DeviceInterface(1)
-    print(dev0.get_idn())
-    print(dev1.get_idn())
-
-    while True:
-        dev0.trigger_scan()
-        dev1.trigger_scan()
-        time.sleep(10)
-        print(dev0.read_resistance_temperature())
-        print(dev1.read_resistance_temperature())
-
-
-if __name__ == '__main__':
-    main()