cgse 2024.7.0__py3-none-any.whl → 2025.0.2__py3-none-any.whl

egse/vacuum/beaglebone/beaglebone.yaml

@@ -1,44 +0,0 @@
-BaseClass:
-    egse.vacuum.beaglebone.BeagleboneInterface
-    
-ProxyClass:
-    egse.vacuum.beaglebone.BeagleboneProxy
-    
-ControlServerClass:
-    egse.vacuum.beaglebone.BeagleboneControlServer
-    
-ControlServer:
-    egse.vacuum.beaglebone.beaglebone_cs
-
-UserInterface:
-    egse.vacuum.beaglebone.beaglebone_ui
-    
-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.
-    
-    
-    # Definition of the device commands
-    set_valve:
-        description: Set the state of a valve.
-        cmd:        "{valve_name}{valve_state}"
-        
-    get_valve:
-        description: Get state of a valve.
-        cmd:        "{valve_name}"

egse/vacuum/beaglebone/beaglebone_cs.py

@@ -1,108 +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.vacuum.beaglebone.beaglebone_protocol import BeagleboneProtocol
-from egse.vacuum.beaglebone.beaglebone import BeagleboneProxy
-
-logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-
-logger = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("BeagleBone Valve 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)
-        
-        self.set_delay(1)
-
-    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_VALVES'
-
-    def before_serve(self):
-        start_http_server(CTRL_SETTINGS.METRICS_PORT)
-
-    def after_serve(self):
-        self.device_protocol.beaglebone.beaglebone._dev_gpio.close()
-
-@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 Valve 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")
-        # 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()
-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/vacuum/beaglebone/beaglebone_devif.py

@@ -1,159 +0,0 @@
-import logging
-import os
-
-from egse.command import ClientServerCommand
-from egse.settings import Settings
-
-logger = logging.getLogger(__name__)
-ctrl_settings = Settings.load('BeagleBone Valve 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.valves= {
-            "MV011"         : 20,
-            "MV012"         : 26,
-            "MV013"         : 27,
-            "MV014"         : 44,
-            "MV021"         : 45,
-            "MV022"         : 46,
-            "MV023"         : 47,
-            "MV024"         : 48,
-            "MV002"         : 49,
-            "MV001"         : 50   
-        }
-        
-        self.valvefb = {
-            "LN2_SHROUD_RMT"     : 61,
-            "LN2_TEB-FEE_RMT"    : 65,
-            "LN2_TEB-TOU_RMT"    : 66,
-            "LN2_TRAP_RMT"       : 67,
-            "N2_SHROUD_RMT"      : 68,
-            "N2_TEB-FEE_RMT"     : 69,
-            "N2_TEB-TOU_RMT"     : 115,
-            "N2_TRAP_RMT"        : 117,
-            "VENT_VALVE_RMT"     : 112,
-            "GATE_VALVE_RMT"     : 2,
-            "LN2_SHROUD_FB"      : 113,
-            "LN2_TEB-FEE_FB"     : 5,
-            "LN2_TEB-TOU_FB"     : 14,
-            "LN2_TRAP_FB"        : 4,
-            "N2_SHROUD_FB"       : 15,
-            "N2_TEB-FEE_FB"      : 89,
-            "N2_TEB-TOU_FB"      : 87,
-            "N2_TRAP_FB"         : 88,
-            "VENT_VALVE_FB"      : 22,
-            "GATE_OPEN_FB"       : 10,
-            "GATE_CLOSE_FB"      : 86,
-            "INTRLCK_DOOR_FB"    : 23
-        }
-
-        self._dev_gpio = Device('gpio_vacuum', config, hal)
-        # self._export_control()
-        # self._export_feedback()
-
-    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 _export_feedback(self):
-        for pin in self.valvefb.values():
-            self._dev_gpio.setMultiple([('GPIO_PIN', pin), ('GPIO_EXPORT', True), ('GPIO_EXPORT', True), ('GPIO_DIRECTION', False)])
-    
-    def _export_control(self):
-        for pin in self.valves.values():
-            self._dev_gpio.setMultiple([('GPIO_PIN', pin), ('GPIO_EXPORT', True), ('GPIO_EXPORT', True), ('GPIO_DIRECTION', True)])
-    
-    def set_valve(self, valve_idx, valve_state):
-        if valve_idx in self.valves.keys():
-            # logger.info(f"{valve_idx} {valve_state}")
-            state = self._dev_gpio.getSetMultiple([('GPIO_PIN', self.valves[valve_idx]), ('GPIO_VALUE', valve_state), ('GPIO_VALUE', None)])
-            return state[0]
-        else:
-            raise ValueError(f"{self.valves[valve_idx]} is not a valid valve ctrl ID")
-
-    def get_valve(self, valve_idx):
-        if valve_idx in self.valvefb.keys():
-            state = self._dev_gpio.getSetMultiple([('GPIO_PIN', self.valvefb[valve_idx]), ('GPIO_VALUE', None)])
-            return state[0]
-        else:
-            raise ValueError(f"{self.valvefb[valve_idx]} is not a valid valve feedback ID")
-
-def main():
-    bbb = BeagleboneDeviceInterface()
-    
-    # Open all valves
-    for i in bbb.valves.values():
-        bbb.set_valve(i, True)
-    
-    # Confirm state of all valves (Remote ON, Valves OPEN)
-    for key, i in bbb.valvefb.items():
-        print(f"{key}: {bbb.get_valve(i)}")
-    
-    input("Confirm remote control ON, Valves OPEN")
-    
-    # Close all valves
-    for i in bbb.valves.values():
-        bbb.set_valve(i, False)
-        
-    # Confirm state of all valves (Remote ON, Valves CLOSED)
-    for key, i in bbb.valvefb.items():
-        print(f"{key}: {bbb.get_valve(i)}")
-        
-    input("Confirm remote control ON, Valves CLOSED")
-        
-    input("Turn all switches to open state")
-    
-    # Confirm state of all valves
-    for key, i in bbb.valvefb.items():
-        print(f"{key}: {bbb.get_valve(i)}")
-        
-    input("Confirm remote control OFF, Valves OPEN")
-    
-    input("Turn all switches to open state")
-    
-    # Confirm state of all valves
-    for key, i in bbb.valvefb.items():
-        print(f"{key}: {bbb.get_valve(i)}")
-
-    input("Confirm remote control OFF, Valves CLOSED") 
-
-
-if __name__ == '__main__':
-    main()

egse/vacuum/beaglebone/beaglebone_protocol.py

@@ -1,192 +0,0 @@
-import logging
-
-from egse.control import ControlServer
-from egse.protocol import CommandProtocol
-from egse.settings import Settings
-
-from prometheus_client import Gauge
-
-from egse.vacuum.beaglebone.beaglebone import BeagleboneController
-from egse.vacuum.beaglebone.beaglebone import BeagleboneInterface
-from egse.vacuum.beaglebone.beaglebone import BeagleboneSimulator
-from egse.vacuum.beaglebone.beaglebone_devif import BeagleboneCommand
-from egse.system import format_datetime
-from egse.zmq_ser import bind_address
-
-logger = logging.getLogger(__name__)
-
-COMMAND_SETTINGS = Settings.load(filename='beaglebone.yaml')
-
-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.gauge_rmt_mv011_fb = Gauge('GSRON_VALVE_RMT_MV011', '')
-        self.gauge_rmt_mv021_fb = Gauge('GSRON_VALVE_RMT_MV012', '')
-        self.gauge_rmt_mv031_fb = Gauge('GSRON_VALVE_RMT_MV013', '')
-        self.gauge_rmt_mv041_fb = Gauge('GSRON_VALVE_RMT_MV014', '')
-        self.gauge_rmt_mv012_fb = Gauge('GSRON_VALVE_RMT_MV021', '')
-        self.gauge_rmt_mv022_fb = Gauge('GSRON_VALVE_RMT_MV022', '')
-        self.gauge_rmt_mv032_fb = Gauge('GSRON_VALVE_RMT_MV023', '')
-        self.gauge_rmt_mv042_fb = Gauge('GSRON_VALVE_RMT_MV024', '')
-        self.gauge_rmt_mv002_fb = Gauge('GSRON_VALVE_RMT_MV002', '')
-        self.gauge_rmt_mv001_fb = Gauge('GSRON_VALVE_RMT_MV001', '')
-
-        self.gauge_oc_mv011_fb = Gauge('GSRON_VALVE_OC_MV011', '')
-        self.gauge_oc_mv021_fb = Gauge('GSRON_VALVE_OC_MV012', '')
-        self.gauge_oc_mv031_fb = Gauge('GSRON_VALVE_OC_MV013', '')
-        self.gauge_oc_mv041_fb = Gauge('GSRON_VALVE_OC_MV014', '')
-        self.gauge_oc_mv012_fb = Gauge('GSRON_VALVE_OC_MV021', '')
-        self.gauge_oc_mv022_fb = Gauge('GSRON_VALVE_OC_MV022', '')
-        self.gauge_oc_mv032_fb = Gauge('GSRON_VALVE_OC_MV023', '')
-        self.gauge_oc_mv042_fb = Gauge('GSRON_VALVE_OC_MV024', '')
-        self.gauge_oc_mv002_fb = Gauge('GSRON_VALVE_OC_MV002', '')
-
-        self.gauge_open_mv001_fb = Gauge('GSRON_VALVE_OPEN_MV001', '')
-        self.gauge_close_mv001_fb = Gauge('GSRON_VALVE_CLOSE_MV001', '')
-        self.gauge_intrlck_door_fb = Gauge('GSRON_VALVE_INTERLOCK_DOOR', '')
-        
-        self.cache = {'feedback' : {},
-                      'remote'   : {}}
-
-
-    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_info = super().get_status()
-        try:
-            remote = {
-                f'GSRON_VALVE_RMT_MV011': self.beaglebone.get_valve('LN2_SHROUD_RMT'),
-                f'GSRON_VALVE_RMT_MV012': self.beaglebone.get_valve('LN2_TEB-FEE_RMT'),
-                f'GSRON_VALVE_RMT_MV013': self.beaglebone.get_valve('LN2_TEB-TOU_RMT'),
-                f'GSRON_VALVE_RMT_MV014': self.beaglebone.get_valve('LN2_TRAP_RMT'),
-                f'GSRON_VALVE_RMT_MV021': self.beaglebone.get_valve('N2_SHROUD_RMT'),
-                f'GSRON_VALVE_RMT_MV022': self.beaglebone.get_valve('N2_TEB-FEE_RMT'),
-                f'GSRON_VALVE_RMT_MV023': self.beaglebone.get_valve('N2_TEB-TOU_RMT'),
-                f'GSRON_VALVE_RMT_MV024': self.beaglebone.get_valve('N2_TRAP_RMT'),
-                f'GSRON_VALVE_RMT_MV002': self.beaglebone.get_valve('VENT_VALVE_RMT'),
-                f'GSRON_VALVE_RMT_MV001': self.beaglebone.get_valve('GATE_VALVE_RMT')
-            }
-
-            feedback = {
-                f'GSRON_VALVE_OC_MV011': self.beaglebone.get_valve('LN2_SHROUD_FB'),
-                f'GSRON_VALVE_OC_MV012': self.beaglebone.get_valve('LN2_TEB-FEE_FB'),
-                f'GSRON_VALVE_OC_MV013': self.beaglebone.get_valve('LN2_TEB-TOU_FB'),
-                f'GSRON_VALVE_OC_MV014': self.beaglebone.get_valve('LN2_TRAP_FB'),
-                f'GSRON_VALVE_OC_MV021': self.beaglebone.get_valve('N2_SHROUD_FB'),
-                f'GSRON_VALVE_OC_MV022': self.beaglebone.get_valve('N2_TEB-FEE_FB'),
-                f'GSRON_VALVE_OC_MV023': self.beaglebone.get_valve('N2_TEB-TOU_FB'),
-                f'GSRON_VALVE_OC_MV024': self.beaglebone.get_valve('N2_TRAP_FB'),
-                f'GSRON_VALVE_OC_MV002': self.beaglebone.get_valve('VENT_VALVE_FB'),
-                f'GSRON_VALVE_OPEN_MV001': self.beaglebone.get_valve('GATE_OPEN_FB'),
-                f'GSRON_VALVE_CLOSE_MV001': self.beaglebone.get_valve('GATE_CLOSE_FB'),
-                f'GSRON_VALVE_INTERLOCK_DOOR': self.beaglebone.get_valve('INTRLCK_DOOR_FB')
-            }
-            
-            
-            # Remember state, even in manual mode
-            if feedback != self.cache['feedback']:
-                for key, value in feedback.items():
-                    code = key.split('_')[-1]
-
-                    if 'DOOR' in key:
-                        continue
-                    elif 'MV001' in key:
-                        if not remote[f'GSRON_VALVE_RMT_{code}']:
-                            if 'OPEN' in key:
-                                if value:
-                                    self.beaglebone.set_valve(code, False)
-                                else:
-                                    self.beaglebone.set_valve(code, True)
-                            if 'CLOSE' in key:
-                                if value:
-                                    self.beaglebone.set_valve(code, True)
-                                else:
-                                    self.beaglebone.set_valve(code, False)
-                    else:
-                        if not remote[f'GSRON_VALVE_RMT_{code}']:
-                            self.beaglebone.set_valve(code, value)
-                        
-            self.cache['feedback'] = feedback
-            self.cache['remote']   = remote
-            
-            status_info['Remote']   = remote
-            status_info['Feedback'] = feedback
-
-        except Exception as exc:
-            logger.info("Status omitted")
-            raise exc 
-        return status_info
-
-
-    def get_housekeeping(self) -> dict:
-        hk_dict = {'timestamp': format_datetime()}
-        try:
-            hk_dict = {
-                'timestamp': format_datetime(),
-                f'GSRON_VALVE_RMT_MV011'     : self.cache['remote']['GSRON_VALVE_RMT_MV011'],
-                f'GSRON_VALVE_RMT_MV012'     : self.cache['remote']['GSRON_VALVE_RMT_MV012'],
-                f'GSRON_VALVE_RMT_MV013'     : self.cache['remote']['GSRON_VALVE_RMT_MV013'],
-                f'GSRON_VALVE_RMT_MV014'     : self.cache['remote']['GSRON_VALVE_RMT_MV014'],
-                f'GSRON_VALVE_RMT_MV021'     : self.cache['remote']['GSRON_VALVE_RMT_MV021'],
-                f'GSRON_VALVE_RMT_MV022'     : self.cache['remote']['GSRON_VALVE_RMT_MV022'],
-                f'GSRON_VALVE_RMT_MV023'     : self.cache['remote']['GSRON_VALVE_RMT_MV023'],
-                f'GSRON_VALVE_RMT_MV024'     : self.cache['remote']['GSRON_VALVE_RMT_MV024'],
-                f'GSRON_VALVE_RMT_MV002'     : self.cache['remote']['GSRON_VALVE_RMT_MV002'],
-                f'GSRON_VALVE_RMT_MV001'     : self.cache['remote']['GSRON_VALVE_RMT_MV001'],
-                f'GSRON_VALVE_OC_MV011'      : self.cache['feedback']['GSRON_VALVE_OC_MV011'],
-                f'GSRON_VALVE_OC_MV012'      : self.cache['feedback']['GSRON_VALVE_OC_MV012'],
-                f'GSRON_VALVE_OC_MV013'      : self.cache['feedback']['GSRON_VALVE_OC_MV013'],
-                f'GSRON_VALVE_OC_MV014'      : self.cache['feedback']['GSRON_VALVE_OC_MV014'],
-                f'GSRON_VALVE_OC_MV021'      : self.cache['feedback']['GSRON_VALVE_OC_MV021'],
-                f'GSRON_VALVE_OC_MV022'      : self.cache['feedback']['GSRON_VALVE_OC_MV022'],
-                f'GSRON_VALVE_OC_MV023'      : self.cache['feedback']['GSRON_VALVE_OC_MV023'],
-                f'GSRON_VALVE_OC_MV024'      : self.cache['feedback']['GSRON_VALVE_OC_MV024'],
-                f'GSRON_VALVE_OC_MV002'      : self.cache['feedback']['GSRON_VALVE_OC_MV002'],
-                f'GSRON_VALVE_OPEN_MV001'    : self.cache['feedback']['GSRON_VALVE_OPEN_MV001'],
-                f'GSRON_VALVE_CLOSE_MV001'   : self.cache['feedback']['GSRON_VALVE_CLOSE_MV001'],
-                f'GSRON_VALVE_INTERLOCK_DOOR': self.cache['feedback']['GSRON_VALVE_INTERLOCK_DOOR']
-            }
-        except Exception as exc:
-            logger.warning(f'failed to get HK ({exc})')
-
-            return hk_dict
-
-        self.gauge_rmt_mv011_fb.set(hk_dict[f'GSRON_VALVE_RMT_MV011'])
-        self.gauge_rmt_mv021_fb.set(hk_dict[f'GSRON_VALVE_RMT_MV012'])
-        self.gauge_rmt_mv031_fb.set(hk_dict[f'GSRON_VALVE_RMT_MV013'])
-        self.gauge_rmt_mv041_fb.set(hk_dict[f'GSRON_VALVE_RMT_MV014'])
-        self.gauge_rmt_mv012_fb.set(hk_dict[f'GSRON_VALVE_RMT_MV021'])
-        self.gauge_rmt_mv022_fb.set(hk_dict[f'GSRON_VALVE_RMT_MV022'])
-        self.gauge_rmt_mv032_fb.set(hk_dict[f'GSRON_VALVE_RMT_MV023'])
-        self.gauge_rmt_mv042_fb.set(hk_dict[f'GSRON_VALVE_RMT_MV024'])
-        self.gauge_rmt_mv002_fb.set(hk_dict[f'GSRON_VALVE_RMT_MV002'])
-        self.gauge_rmt_mv001_fb.set(hk_dict[f'GSRON_VALVE_RMT_MV001'])
-
-        self.gauge_oc_mv011_fb.set(hk_dict[f'GSRON_VALVE_OC_MV011'])
-        self.gauge_oc_mv021_fb.set(hk_dict[f'GSRON_VALVE_OC_MV012'])
-        self.gauge_oc_mv031_fb.set(hk_dict[f'GSRON_VALVE_OC_MV013'])
-        self.gauge_oc_mv041_fb.set(hk_dict[f'GSRON_VALVE_OC_MV014'])
-        self.gauge_oc_mv012_fb.set(hk_dict[f'GSRON_VALVE_OC_MV012'])
-        self.gauge_oc_mv022_fb.set(hk_dict[f'GSRON_VALVE_OC_MV022'])
-        self.gauge_oc_mv032_fb.set(hk_dict[f'GSRON_VALVE_OC_MV023'])
-        self.gauge_oc_mv042_fb.set(hk_dict[f'GSRON_VALVE_OC_MV024'])
-        self.gauge_oc_mv002_fb.set(hk_dict[f'GSRON_VALVE_OC_MV002'])
-
-        self.gauge_open_mv001_fb.set(hk_dict[f'GSRON_VALVE_OPEN_MV001'])
-        self.gauge_close_mv001_fb.set(hk_dict[f'GSRON_VALVE_CLOSE_MV001'])
-        self.gauge_intrlck_door_fb.set(hk_dict[f'GSRON_VALVE_INTERLOCK_DOOR'])
-
-        return hk_dict