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

egse/lampcontrol/beaglebone/beaglebone.yaml

@@ -1,62 +0,0 @@
-BaseClass:
-    egse.lampcontrol.beaglebone.BeagleboneInterface
-
-ProxyClass:
-    egse.lampcontrol.beaglebone.BeagleboneProxy
-
-ControlServerClass:
-    egse.lampcontrol.beaglebone.BeagleboneControlServer
-
-ControlServer:
-    egse.lampcontrol.beaglebone.beaglebone_cs
-
-Commands:
-
-    # Definition of the DeviceInterface
-
-    disconnect:
-        description: Discconect from the Valve Controller.
-
-    connect:
-        description: Connect to the Valve controller.
-
-    reconnect:
-        description: Reconnect to the Valve controller.
-
-    is_simulator:
-        description: Ask if the control server is a is a simulator.
-        returns:    bool | True if far en is a simulator.
-
-    is_connected:
-        description: Checl of Valve Controller is connected.
-
-    set_lamp:
-        description:    Sets the lamp to the given state
-        args:
-            state:      int | State of the lamp
-        cmd:            "{state}"
-
-    set_interlock:
-        description:    Sets the interlock to the given state
-        args:
-            state:      int | state of the lamp
-        cmd:            "{state}"
-
-    get_lamp_on:
-        description:    Returns the on state of the lamp
-        returns:        bool | True if lamp is on
-
-    get_laser_on:
-        description:    Returns the on state of the laser
-        returns:        bool | True is laser is on
-
-    get_lamp_module_fault:
-        description:    Returns the state of the fault of the lamp
-        returns:        bool | True is there is a fault
-
-    get_controller_fault:
-        description:    Returns the state of the fault of the controller
-        returns:        bool | True is there is a fault
-
-    fix_controller_fault:
-        description:    Fixes the controller fault

egse/lampcontrol/beaglebone/beaglebone_cs.py

@@ -1,106 +0,0 @@
-# Control server for the BeagleBone Black valve controller
-
-import click
-import logging
-import sys
-
-import zmq
-from prometheus_client import start_http_server
-
-from egse.control import ControlServer
-from egse.settings import Settings
-from egse.lampcontrol.beaglebone.beaglebone_protocol import BeagleboneProtocol
-from egse.lampcontrol.beaglebone.beaglebone import BeagleboneProxy
-
-logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-
-logger = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("BeagleBone Lamp Control Server")
-
-
-class BeagleBoneControlServer(ControlServer):
-
-    def __init__(self):
-        super().__init__()
-
-        self.device_protocol = BeagleboneProtocol(self)
-
-        self.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.COMMANDING_PORT
-
-    def get_service_port(self):
-        return CTRL_SETTINGS.SERVICE_PORT
-
-    def get_monitoring_port(self):
-        return CTRL_SETTINGS.MONITORING_PORT
-
-    def get_storage_mnemonic(self):
-        try:
-            return CTRL_SETTINGS.STORAGE_MNEMONIC
-        except:
-            return 'BBB_GSM'
-
-    def before_serve(self):
-        start_http_server(CTRL_SETTINGS.METRICS_PORT)
-        
-    def after_serve(self):
-        self.device_protocol.beaglebone.beaglebone._dev_gpio.close()
-        self.device_protocol.synoptics.disconnect_cs()
-
-
-@click.group()
-def cli():
-    pass
-
-
-@cli.command()
-@click.option("--simulator", "--sim", is_flag=True, help="Start the BeagleBone Valve Controller Simulator as the backend.")
-def start(simulator):
-    """Start the BeagleBone Lamp Control Server."""
-
-    if simulator:
-        Settings.set_simulation_mode(True)
-    try:
-        control_server = BeagleBoneControlServer()
-        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 BeagleBone Valve Control Server")
-
-    return 0
-
-
-@cli.command()
-def stop():
-    """Send a 'quit_server' command to the Control Server."""
-
-    with BeagleboneProxy() as proxy:
-
-        sp = proxy.get_service_proxy()
-        sp.quit_server()
-
-
-if __name__ == "__main__":
-
-    sys.exit(cli())

egse/lampcontrol/beaglebone/beaglebone_devif.py

@@ -1,150 +0,0 @@
-import logging
-import struct
-import time
-import socket
-import errno
-import os
-
-from egse.command import ClientServerCommand
-from egse.exceptions import DeviceNotFoundError
-from egse.settings import Settings
-
-LAMP = 50
-EX_INTERLOCK = 20
-
-LAMP_ON=66
-LASER_ON=61
-LAMP_MODULE_FAULT = 67
-CONTROLLER_FAULT = 65
-
-logger = logging.getLogger(__name__)
-ctrl_settings = Settings.load('BeagleBone Lamp Control Server')
-
-
-class BeagleboneCommand(ClientServerCommand):
-    def get_cmd_string(self, *args, **kwargs):
-        out = super().get_cmd_string(*args, **kwargs)
-        return out + '\n'
-
-
-class BeagleboneDeviceInterface:
-    def __init__(self):
-
-        # Perform SRON gssw imports here to avoid issues at other THs
-        from gssw.config.configclient import ConfigClient
-        from gssw.common import addLoggingLevel
-        from gssw.hal.hal import Hal
-        from gssw.hal.halclient import HalClient
-        from gssw.lib.device import Device
-
-        self._is_connected = False
-
-        # InitGssw does something to zmq that breaks cgse logging.
-        # So instead I copied the essentials here.
-        configClient = ConfigClient(os.getenv('GSSW_CONFIGURATION_FILE'))
-        config = configClient.config
-        addLoggingLevel('data', 15)
-
-        hal = Hal()
-        hal_client = HalClient(hal, config)
-        hal_client.requestHal()
-
-        self._dev_gpio = Device('gpio_gsm', config, hal)
-
-    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 is_connected(self):
-        return self._is_connected
-
-    def set_lamp(self, state):
-        try:
-            logger.info(f"Lamp source is now: {'ON' if state == 1 else 'Off'}")
-            self._dev_gpio.setMultiple([('GPIO_PIN', LAMP), ('GPIO_VALUE', state)])
-        except Exception as exc:
-            logger.error(f'Could not turn on the light source: {exc}')
-            raise exc
-
-    def set_interlock(self, state):
-        try:
-            logger.info(f"Lamp external interlock is now: {'ON' if state == 1 else 'Off'}")
-            self._dev_gpio.setMultiple([('GPIO_PIN', EX_INTERLOCK), ('GPIO_VALUE', state)])
-        except Exception as exc:
-            logger.error(f'Could not turn set interlock: {exc}')
-            raise exc
-
-    def get_lamp_on(self):
-        try:
-            lamp_on = self._dev_gpio.getSetMultiple([("GPIO_PIN", LAMP_ON), ("GPIO_VALUE", None)])
-            return bool(not lamp_on[0])
-        except Exception as exc:
-            logger.error(f'Could not read lamp state: {exc}')
-            raise exc
-
-    def get_laser_on(self):
-        try:
-            laser_on = self._dev_gpio.getSetMultiple([("GPIO_PIN", LASER_ON), ("GPIO_VALUE", None)])
-            return bool(not laser_on[0])
-        except Exception as exc:
-            logger.error(f'Could not get laser state: {exc}')
-            raise exc
-
-    def get_lamp_module_fault(self):
-        try:
-            lamp_module_fault = self._dev_gpio.getSetMultiple([("GPIO_PIN", LAMP_MODULE_FAULT), ("GPIO_VALUE", None)])
-            return bool(lamp_module_fault[0])
-        except Exception as exc:
-            logger.error(f'Could not get lamp module faults: {exc}')
-            raise exc
-        
-    def get_controller_fault(self):
-        try:
-            controller_fault = self._dev_gpio.getSetMultiple([("GPIO_PIN", CONTROLLER_FAULT), ("GPIO_VALUE", None)])
-            return bool(controller_fault[0])
-        except Exception as exc:
-            logger.error(f'Could not get controller faults: {exc}')
-            raise exc
-        
-    def fix_controller_fault(self):
-        # 1. Close interlocks
-        self.set_interlock(True)
-        # 2. Turn on lamp
-        self.set_lamp(True)
-        # 3. Wait for a second
-        time.sleep(2)
-        # 4. Disable lamp 
-        self.set_lamp(False)
-            
-
-def main():
-    bbb = BeagleboneDeviceInterface()
-    
-    print(f"Lamp state: {bbb.get_lamp_on()}\n"\
-          f"Laster state: {bbb.get_laser_on()}\n"\
-          f"Module fault: {bbb.get_lamp_module_fault()}\n"\
-          f"Controller fault: {bbb.get_controller_fault()}\n")
-    # bbb.set_lamp(True)
-    
-    # while not bbb.get_lamp_on():
-    #     pass
-    
-    # while not bbb.get_laser_on():
-    #     pass
-    
-    # print(f"Lamp state: {bbb.get_lamp_on()}\n"\
-    #       f"Laster state: {bbb.get_laser_on()}\n"\
-    #       f"Module fault: {bbb.get_lamp_module_fault()}\n"\
-    #       f"Controller fault: {bbb.get_controller_fault()}")
-    
-
-
-if __name__ == '__main__':
-    main()

egse/lampcontrol/beaglebone/beaglebone_protocol.py

@@ -1,73 +0,0 @@
-from egse.control import ControlServer
-from egse.protocol import CommandProtocol
-from egse.settings import Settings
-
-from prometheus_client import Gauge
-
-from egse.lampcontrol.beaglebone.beaglebone import BeagleboneController
-from egse.lampcontrol.beaglebone.beaglebone import BeagleboneInterface
-from egse.lampcontrol.beaglebone.beaglebone import BeagleboneSimulator
-from egse.lampcontrol.beaglebone.beaglebone_devif import BeagleboneCommand
-from egse.synoptics import SynopticsManagerProxy
-from egse.system import format_datetime
-from egse.zmq_ser import bind_address
-
-COMMAND_SETTINGS = Settings.load(filename='beaglebone.yaml')
-SITE_ID = Settings.load("SITE").ID
-
-gauge_lamp_on = Gauge("GSRON_LAMP_LAMP_ON", "")
-gauge_laser_on = Gauge("GSRON_LAMP_LASER_ON", "")
-gauge_lamp_module_fault = Gauge("GSRON_LAMP_MODULE_FAULT", "")
-gauge_controller_fault = Gauge("GSRON_LAMP_CTRL_FAULT", "")
-
-
-class BeagleboneProtocol(CommandProtocol):
-    def __init__(self, control_server:ControlServer):
-        super().__init__()
-        self.control_server = control_server
-
-        if Settings.simulation_mode():
-            self.beaglebone = BeagleboneSimulator()
-        else:
-            self.beaglebone = BeagleboneController()
-
-        self.load_commands(COMMAND_SETTINGS.Commands, BeagleboneCommand, BeagleboneInterface)
-
-        self.build_device_method_lookup_table(self.beaglebone)
-
-        self.synoptics = SynopticsManagerProxy()
-
-    def get_bind_address(self):
-        return bind_address(self.control_server.get_communication_protocol(),
-                            self.control_server.get_commanding_port())
-
-    def get_status(self):
-        status_dict = super().get_status()
-        status_dict['lamp_status'] = {
-            'lamp_state' : self.beaglebone.get_lamp_on(),
-            'laser_state' : self.beaglebone.get_laser_on(),
-            'module_fault' : self.beaglebone.get_lamp_module_fault(),
-            'controller_fault' : self.beaglebone.get_controller_fault()
-        }
-        return status_dict
-
-    def get_housekeeping(self) -> dict:
-
-        hk_dict = dict()
-        hk_dict['timestamp'] = format_datetime()
-
-        hk_dict['GSRON_LAMP_LAMP_ON'] = self.beaglebone.get_lamp_on()
-        hk_dict['GSRON_LAMP_LASER_ON'] = self.beaglebone.get_laser_on()
-
-        # Send the HK acquired so far to the Synoptics Manager
-        self.synoptics.store_th_synoptics(hk_dict)
-
-        hk_dict['GSRON_LAMP_MODULE_FAULT'] = self.beaglebone.get_lamp_module_fault()
-        hk_dict['GSRON_LAMP_CTRL_FAULT'] = self.beaglebone.get_controller_fault()
-
-        gauge_lamp_on.set(hk_dict['GSRON_LAMP_LAMP_ON'])
-        gauge_laser_on.set(hk_dict['GSRON_LAMP_LASER_ON'])
-        gauge_lamp_module_fault.set(hk_dict['GSRON_LAMP_MODULE_FAULT'])
-        gauge_controller_fault.set(hk_dict['GSRON_LAMP_CTRL_FAULT'])
-
-        return hk_dict

egse/lampcontrol/energetiq/__init__.py

@@ -1,22 +0,0 @@
-"""
-Device control for the EQ-99 Manager that controls the Hamamatsu Lamp.
-
-The main entry point for the user of this package is through the `Eq99Proxy` class:
-
-```python
->>> from egse.lampcontrol.energetiq.lampEQ99 import LampEQ99Proxy
-```
-
-This class will connect to the control server of the filter wheel and provides all commands to
-control this device and monitor its settings and status.
-
-We have also provided a graphical user interface (GUI) to monitor and manipulate the filter wheel.
-For this, execute the following command from the terminal. We assume hereby that your environment
-and `PYTHONPATH` are set up properly.
-
-```bash
-$ python -m egse.lampcontrol.energetiq.eq99_cs
-```
-
-
-"""

egse/lampcontrol/energetiq/eq99.yaml

@@ -1,98 +0,0 @@
-BaseClass:
-    egse.lampcontrol.energetiq.lampEQ99.LampEQ99Interface
-
-ProxyClass:
-    egse.lampcontrol.energetiq.lampEQ99.LampEQ99Proxy
-
-ControlServerClass:
-    egse.lampcontrol.energetiq.lampEQ99_cs.LampEQ99ControlServer
-
-ControlServer:
-    egse.lampcontrol.energetiq.lampEQ99_cs
-
-UserInterface:
-    egse.lampcontrol.energetiq.lampEQ99_ui
-
-Commands:
-
-    # Each of these groups is parsed and used on both the server and the client side.
-    # The group name (e.g. is_simulator) will be monkey patched in the Proxy class for the device or service.
-    # The other field are:
-    #   description:   Used by the doc_string method to generate a help string
-    #   cmd:           Command string that will eventually be send to the hardware controller for the
-    #                  device after the arguments have been filled.
-    #   device_method: The name of the method to be called on the device class.
-    #                  These should all be defined by the base class for the device.
-    #                  This method should exist in the subclass of the CommandProtocol base class.
-
-    # Definition of the the DeviceInterface
-
-    connect:
-        description:    Connect the Filter Wheel hardware controller
-
-    reconnect:
-        description:    Reconnect the Lamp hardware controller.
-
-                        This command will force a disconnect and then try to re-connect to the controller.
-
-    disconnect:
-        description  : Disconnect from the Lamp controller. This command will be send to the
-                       Thorlabs Control Server which will then disconnect from the hardware controller.
-                       This command doesn't affect the ZeroMQ connection of this Proxy to the
-                       control server. Use the service command `disconnect_cs()` to disconnect
-                       from the control server.
-
-    is_connected:
-        description:   Check if the Thorlabs Hardware Controller is connected.
-
-    is_simulator:
-        description:   Ask if the control server is a simulator instead of the real LampEQ99Controller class.
-        returns:       bool | True if the far end is a simulator instead of the real hardware
-
-    get_id:
-        description:   Retrieve the rSCPI Identification for the Lamp.
-        returns:       str | The IDN for the given device
-
-    info:
-      description: Retrieve basic information about the Lamp and the Controller.
-
-
-    # Definition of the device commands
-
-    ldls_reset:
-        description:  Resets the instrument to the factory default and the ouput is shut off. The unit remains in
-                      remote mode
-        returns:      None
-
-    lamp_errors:
-        description:  Returns a comma delimited list of error codes with a string description included.
-                      If no error has occurred, a 0 is returned.
-        returns:      dict | ErrorCode and ErrorMessage
-
-    set_lamp:
-        description:  Turns the lamp output on or off
-        args:
-          _enable:    bool | "0" disables "1" enables
-        cmd:          "{_enable}"
-        returns:      None
-
-    get_lamp:
-        description:  Returns the output state. Will return true as soon as the turned on process has started, even if
-                      the lamp has not yet turned on. To determine the lamp and laser state use get_lamp_state
-        returns:      bool | 0 OFF 1 ON
-
-    set_lamp_time:
-        description: Resets the lamp runtime to the new value in hours.
-        args:
-          _time:      float | the number of hours from 0 to 999
-        cmd:          "{_time}"
-        returns:      None
-
-    get_lamp_time:
-        description: The number of hours accumulated while the lamp was on. The value is in hours.
-        returns:     int | number of hours
-
-    get_lamp_status:
-        description: Returns the LDLS condition register. The condition register reflects the state of the instrument at
-                     the time the condition register is read.
-        returns:     dict | with all the bit status TBW