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

egse/tempcontrol/agilent/agilent34970_protocol.py

@@ -1,99 +0,0 @@
-import logging
-
-from prometheus_client import Gauge
-
-from egse.protocol import CommandProtocol
-from egse.settings import Settings
-from egse.setup import get_setup
-from egse.confman import ConfigurationManagerProxy
-# from egse.fdir.fdir_manager import FdirManagerProxy
-from egse.state import GlobalState
-from egse.synoptics import SynopticsManagerProxy
-from egse.tempcontrol.agilent.agilent34970 import Agilent34970Controller
-from egse.tempcontrol.agilent.agilent34970 import Agilent34970Interface
-from egse.tempcontrol.agilent.agilent34970 import Agilent34970Simulator
-from egse.tempcontrol.agilent.agilent34970_devif import Agilent34970Command
-from egse.system import format_datetime
-from egse.zmq_ser import bind_address
-
-logger = logging.getLogger(__name__)
-
-FDIR_PREFIX = 600
-
-COMMAND_SETTINGS = Settings.load(filename='agilent34970.yaml')
-
-class Agilent34970Protocol(CommandProtocol):
-
-    def __init__(self, control_server, device_index):
-
-        super().__init__()
-
-        self.control_server = control_server
-        self.device_index = device_index
-
-        if Settings.simulation_mode():
-            self.agilent = Agilent34970Simulator()
-        else:
-            self.agilent = Agilent34970Controller(self.device_index)
-
-        self.load_commands(COMMAND_SETTINGS.Commands, Agilent34970Command, Agilent34970Interface)
-
-        self.build_device_method_lookup_table(self.agilent)
-
-        # Get scan list from setup
-        setup = GlobalState.setup
-
-        self._setup = setup['gse'][f'agilent34970_{device_index}']
-        self._conversions = self._setup['conversion']
-        self.channels = []
-
-        self.channels += self._setup.thermocouples
-        self.channels += self._setup.two_wire
-        self.channels += self._setup.four_wire
-        self.channels.sort()
-
-        self.resistance_gauges = [
-            Gauge(f'GSRON_AG34970_{device_index}_R{channel}', '') for channel in self.channels]
-        self.temperature_gauges = [
-            Gauge(f'GSRON_AG34970_{device_index}_T{channel}', '') for channel in self.channels]
-
-
-    def get_bind_address(self):
-        return bind_address(self.control_server.get_communication_protocol(),
-                            self.control_server.get_commanding_port())
-
-    def get_status(self):
-        return super().get_status()
-
-    def get_housekeeping(self) -> dict:
-
-        hk_dict = {'timestamp': format_datetime()}
-
-        try:
-            resistances, temperatures = self.agilent.read_resistance_temperature()
-            self.agilent.trigger_scan()
-        except Exception as e:
-            logger.warning(f'failed to get HK ({e})')
-
-            with SynopticsManagerProxy() as synoptics:
-                synoptics.store_th_synoptics(hk_dict)
-
-            return hk_dict
-
-        if len(temperatures.values()) == len(self.channels) and len(resistances.values()) == len(self.channels):
-            for idx, (chnl, temp) in enumerate(temperatures.items()):
-                hk_dict[f'GSRON_AG34970_{self.device_index}_T{chnl}'] = temp
-                self.temperature_gauges[idx].set(temp)
-                
-            for idx, (chnl, res) in enumerate(resistances.items()):
-                hk_dict[f'GSRON_AG34970_{self.device_index}_R{chnl}'] = res
-                self.resistance_gauges[idx].set(res)
-        else:
-            logger.warning(f'Invalid scan result')
-
-        # Store the temperatures as synoptics
-
-        with SynopticsManagerProxy() as synoptics:
-            synoptics.store_th_synoptics(hk_dict)
-
-        return hk_dict

egse/tempcontrol/agilent/agilent34972.py

@@ -1,111 +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.agilent34972_devif import Agilent34972Error
-from egse.tempcontrol.agilent.agilent34972_devif import Agilent34972DeviceInterface
-from egse.zmq_ser import connect_address
-
-logger = logging.getLogger(__name__)
-
-DEVICE_SETTINGS = Settings.load(filename='agilent34972.yaml')
-CTRL_SETTINGS = Settings.load("Agilent 34972 Control Server")
-
-
-class Agilent34972Interface(DeviceInterface):
-    """ Agilent 34972 base class."""
-
-    @dynamic_interface
-    def get_idn(self):
-        """ Get Agilent34972 IDN message. """
-        return NotImplemented
-
-    @dynamic_interface
-    def read_resistance_temperature(self, scan_list=None):
-        """ Measure 4-wire resistance. """
-        return NotImplemented
-    
-    @dynamic_interface
-    def trigger_scan(self):
-        """ Perform a scan of th specified channels"""
-        return NotImplemented
-
-
-class Agilent34972Simulator(Agilent34972Interface):
-    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 'Agilent34972'
-
-    def read_resistance_temperature(self):
-        return [0, 0, 0, 0], [0, 0, 0, 0]
-    
-    def trigger_scan(self):
-        pass
-
-class Agilent34972Controller(Agilent34972Interface):
-
-    # The device index is used to distinguish between the 2 agilent34972 devices
-    def __init__(self, device_index):
-        super().__init__()
-
-        logger.debug(f'Initalizing Agilent34972 Controller {device_index}')
-
-        try:
-            self.agilent = Agilent34972DeviceInterface(device_index)
-        except Agilent34972Error as exc:
-            logger.warning(f"Agilent34972Error caught: Couldn't establish connectin ({exc})")
-            raise Agilent34972Error(
-                "Couldn't establish a connection with Agilent34972 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 Agilent34972Proxy(Proxy, Agilent34972Interface):
-    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/agilent34972.yaml

@@ -1,44 +0,0 @@
-BaseClass:
-    egse.tempcontrol.agilent.Agilent34972Interface
-
-ProxyClass:
-    egse.tempcontrol.agilent.Agilent34972Proxy
-
-ControlServerClass:
-    egse.tempcontrol.agilent.Agilent34972ControlServer
-
-ControlServer:
-    egse.tempcontrol.agilent.agilent34972_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 Agilent34972 Controller.
-
-    connect:
-        description: Connect to the Agilent34972 Controller.
-
-    reconnect:
-        description: Reconnect to the Agilent34972 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 Agilent34972 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/agilent34972_cs.py

@@ -1,117 +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 = "agilent34972_cs"
-
-from egse.control import ControlServer
-from egse.settings import Settings
-from egse.zmq_ser import connect_address
-from egse.tempcontrol.agilent.agilent34972 import Agilent34972Interface, Agilent34972Proxy
-from egse.tempcontrol.agilent.agilent34972_protocol import Agilent34972Protocol
-
-
-logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-
-logger = logging.getLogger('__name__')
-
-CTRL_SETTINGS = Settings.load("Agilent 34972 Control Server")
-
-
-class Agilent34972ControlServer(ControlServer):
-
-    def __init__(self, index):
-        self.index = index
-        self.name = "DAQ"+str(index)
-        super(Agilent34972ControlServer, self).__init__()
-
-        self.device_protocol = Agilent34972Protocol(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'Agilent34972_{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 Agilent34972 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 34972 {index} Control Server')
-        
-        multiprocessing.current_process().name = f"agilent34972_cs_{index}"
-
-        control_server = Agilent34972ControlServer(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 Agilent34972Proxy(index) as proxy:
-
-        sp = proxy.get_service_proxy()
-        sp.quit_server()
-
-
-if __name__ == "__main__":
-
-    sys.exit(cli())

egse/tempcontrol/agilent/agilent34972_devif.py

@@ -1,189 +0,0 @@
-#!/usr/bin/env python3
-
-import logging
-import time
-
-from egse.command import ClientServerCommand
-from egse.exceptions import DeviceNotFoundError
-from egse.settings import Settings
-from egse.setup import get_setup
-from egse.socketdevice import SocketDevice
-
-logger = logging.getLogger(__name__)
-
-
-class Agilent34972Error(Exception):
-    pass
-
-
-class Agilent34972Command(ClientServerCommand):
-    def get_cmd_string(self, *args, **kwargs):
-        out = super().get_cmd_string(*args, **kwargs)
-        return out + '\n'
-
-
-class Agilent34972DeviceInterface(SocketDevice):
-
-    def __init__(self, device_index):
-        self._ctrl_settings = Settings.load(f'Agilent 34972 Controller')        
-        self._setup = get_setup()
-
-        self.device_index = device_index
-        
-        self._is_connected = [False]
-        self._timeout = 20
-        self._command_interval = 0
-        self._process_delay = 0.1
-        self._sock_buffsize = 1024
-        
-        self._host = self._ctrl_settings[f'DAQ {device_index}']['HOST']
-        self._port = self._ctrl_settings[f'DAQ {device_index}']['PORT']
-
-        self._setup = self._setup['gse'][f'agilent34972_{device_index}']
-        self._conversions = self._setup['conversion']
-            
-        super().__init__(hostname=self._host, port=self._port, 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 != []:
-#            breakpoint()
-            self.send_command(f"CONF:RES {two_wire_list}\n")
-            time.sleep(1)
-        if four_wire_list != []:
-#            breakpoint()
-            self.send_command(f"CONF:FRES {four_wire_list}\n")
-            time.sleep(1)
-        if thermocouple_list != []:
-#            breakpoint()
-            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"R? {len(self.scanlist)}\n")
-        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 = Agilent34972DeviceInterface(0)
-    dev1 = Agilent34972DeviceInterface(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()

egse/tempcontrol/agilent/agilent34972_protocol.py

@@ -1,101 +0,0 @@
-import logging
-
-from prometheus_client import Gauge
-
-from egse.confman import ConfigurationManagerProxy
-# from egse.fdir.fdir_manager import FdirManagerProxy
-from egse.protocol import CommandProtocol
-from egse.settings import Settings
-from egse.setup import get_setup
-from egse.synoptics import SynopticsManagerProxy
-from egse.system import format_datetime
-from egse.tempcontrol.agilent.agilent34972 import Agilent34972Controller
-from egse.tempcontrol.agilent.agilent34972 import Agilent34972Interface
-from egse.tempcontrol.agilent.agilent34972 import Agilent34972Simulator
-from egse.tempcontrol.agilent.agilent34972_devif import Agilent34972Command
-from egse.zmq_ser import bind_address
-from egse.synoptics import SynopticsManagerProxy
-
-logger = logging.getLogger(__name__)
-
-FDIR_PREFIX = 600
-
-COMMAND_SETTINGS = Settings.load(filename='agilent34972.yaml')
-
-
-class Agilent34972Protocol(CommandProtocol):
-    def __init__(self, control_server, device_index):
-
-        super().__init__()
-
-        self.control_server = control_server
-        self.cs_storage_mnemonic = self.control_server.get_storage_mnemonic()
-        self.device_index = device_index
-
-        if Settings.simulation_mode():
-            self.agilent = Agilent34972Simulator()
-        else:
-            self.agilent = Agilent34972Controller(self.device_index)
-
-        self.load_commands(COMMAND_SETTINGS.Commands, Agilent34972Command, Agilent34972Interface)
-
-        self.build_device_method_lookup_table(self.agilent)
-
-        # Get scan list from setup
-        setup = get_setup()
-
-        self._setup = setup['gse'][f'agilent34972_{device_index}']
-        self._conversions = self._setup['conversion']
-        self.channels = []
-
-        self.channels += self._setup.thermocouples
-        self.channels += self._setup.two_wire
-        self.channels += self._setup.four_wire
-        self.channels.sort()
-
-        self.resistance_gauges = [
-            Gauge(f'GSRON_AG34972_{self.device_index}_R{channel}', '') for channel in self.channels]
-        self.temperature_gauges = [
-            Gauge(f'GSRON_AG34972_{self.device_index}_T{channel}', '') for channel in self.channels]
-
-
-    def get_bind_address(self):
-        return bind_address(self.control_server.get_communication_protocol(),
-                            self.control_server.get_commanding_port())
-
-    def get_status(self):
-        return super().get_status()
-
-
-    def get_housekeeping(self) -> dict:
-
-        hk_dict = {'timestamp': format_datetime()}
-
-        try:
-            resistances, temperatures = self.agilent.read_resistance_temperature()
-            self.agilent.trigger_scan()
-        except Exception as e:
-            logger.warning(f'failed to get HK ({e})')
-
-            with SynopticsManagerProxy() as synoptics:
-                synoptics.store_th_synoptics(hk_dict)
-
-            return hk_dict
-
-        if len(temperatures.values()) == len(self.channels) and len(resistances.values()) == len(self.channels):
-            for idx, (chnl, temp) in enumerate(temperatures.items()):
-                hk_dict[f'GSRON_AG34972_{self.device_index}_T{chnl}'] = temp
-                self.temperature_gauges[idx].set(temp)
-                
-            for idx, (chnl, res) in enumerate(resistances.items()):
-                hk_dict[f'GSRON_AG34972_{self.device_index}_R{chnl}'] = res
-                self.resistance_gauges[idx].set(res)
-        else:
-            logger.warning(f'Invalid scan result')
-
-        # Store the temperatures as synoptics
-
-        with SynopticsManagerProxy() as synoptics:
-            synoptics.store_th_synoptics(hk_dict)
-
-        return hk_dict