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

egse/dsi/rmapci.py

@@ -1,37 +0,0 @@
-# RMAP Configuration Interface
-#
-# This file implements functions to easily create the packets send over the RMAP protocol
-# for the DPU-FEE interface.
-#
-# Please check the document PLATO-DLR-PL-IC-0002 v1.0 [25/09/2018] for reference. 
-# The RMAP Verified Write Request Packet STructure is defined on page 26 with req. FEE-DPU-IF-582.
-
-import egse.dsi.rmap
-
-
-# FIXME: We could just use the rmap_write(..) command for this, but that currently doesn't have verify before write etc.
-# It more looks like the RMAP interface to the device can also (better) be implemented in Python.
-
-def write_critical_configuration_data(rmap_link, buf, tid, addr, data):
-    buf[0]  = egse.dsi.rmap.rmap_get_target_logical_address(rmap_link)
-    buf[1]  = egse.dsi.constants.RMAP_PROTOCOL_ID
-    buf[2]  = 0x7C                    # Instruction: RMAP Request, write, incrementing address, verify before write, and send reply, reply addr length=0
-    buf[3]  = 0xD1                    # Key:
-    buf[4]  = egse.dsi.rmap.rmap_get_initiator_logical_address(rmap_link)
-    buf[5]  = (tid >> 8) & 0xFF       # MSB of the Transition ID
-    buf[6]  = (tid) & 0xFF            # LSB of the Transition ID
-    buf[7]  = (addr >> 32) & 0xFF     # Extended address
-    buf[8]  = (addr >> 24) & 0xFF     # address (MSB)
-    buf[9]  = (addr >> 16) & 0xFF     # address
-    buf[10] = (addr >>  8) & 0xFF     # address
-    buf[11] = (addr      ) & 0xFF     # address (LSB)
-    buf[12] = 0x00                    # data length (MSB)
-    buf[13] = 0x00                    # data length, fixed to 4 bytes for critical configuration parameters
-    buf[14] = 0x04                    # data length (LSB)
-    buf[15] = egse.dsi.rmap.rmap_crc_check(buf, 0, 15)
-    buf[16] = (data >> 24) & 0xFF     # data (MSB)
-    buf[17] = (data >> 16) & 0xFF     # data
-    buf[18] = (data >>  8) & 0xFF     # data
-    buf[19] = (data      ) & 0xFF     # data (LSB)
-    buf[20] = egse.dsi.rmap.rmap_crc_check(buf, 16, 4)
-    return buf

egse/dsi/spw.py

@@ -1,154 +0,0 @@
-"""
-This module contains functions to handle SpaceWire communication.
-"""
-
-import logging
-from typing import Tuple
-
-from egse.dsi import constants
-from egse.dsi.esl import esl_close_connection
-from egse.dsi.esl import esl_configure
-from egse.dsi.esl import esl_flush
-from egse.dsi.esl import esl_open_connection
-from egse.dsi.esl import esl_read_packet
-from egse.dsi.esl import esl_send_timecode
-from egse.dsi.esl import esl_write_packet
-from egse.dsi.rmap import rmap_configure
-from egse.dsi.rmap import rmap_open_connection
-from egse.dsi.rmap import rmap_read_request
-from egse.dsi.rmap import rmap_write_request
-from egse.settings import Settings
-from egse.spw import SpaceWireInterface
-from egse.spw import SpaceWirePacket
-
-logger = logging.getLogger(__name__)
-
-DSI_SETTINGS = Settings.load("DSI")
-
-# Naming conventions:
-#
-# rx_buffer:
-#     is used for any buffer (of type bytes) that is or was received over the SpaceWire interface.
-# tx_buffer:
-#     is used for any buffer (of type bytes) that will be transmitted over the SpaceWire interface.
-
-
-def handle_extension_packet(rx_buffer: bytes, bytes_received: int):
-    """
-    Decide how to handle the extension packet that was received over the SpaceWire.
-
-    The following extension packets are supported:
-
-    * a timecode packet
-
-    Args:
-        rx_buffer (bytes): the packet that was received as a bytes object
-        bytes_received (int): the length of the rx_buffer (allocated space might be larger)
-
-    Returns:
-        Nothing: yet.
-
-    """
-    logger.debug("*" * 80)
-    logger.debug("Extension Packet returned by DSI")
-    logger.debug(
-        f"extension packet: {bin(int.from_bytes(rx_buffer, 'big'))} (length={bytes_received})"
-    )
-    logger.debug("*" * 80)
-
-
-def handle_special_packet(rx_buffer: bytes, bytes_received: int):
-    """
-
-    Args:
-        rx_buffer (bytes): the packet that was received as a bytes object
-        bytes_received (int): the length of the rx_buffer (allocated space might be larger)
-
-    Returns:
-        Nothing: yet.
-
-    """
-    logger.debug("Special Packet returned by DSI")
-    logger.debug(f"extension packet: {rx_buffer}")
-
-
-class SpaceWireOverDSI(SpaceWireInterface):
-    """
-    The SpaceWireOverDSI implements the SpaceWire communication/transport over a Diagnostic
-    SpaceWire Interface (DSI).
-    """
-
-    def __init__(self, dsi_address, dsi_port):
-        self.dsi_address = dsi_address
-        self.dsi_port = dsi_port
-        self.esl_link = None
-        self.rmap_link = None
-
-    def connect(self):
-        self.esl_link = esl_open_connection(self.dsi_address)
-        self.rmap_link = rmap_open_connection(self.esl_link)
-        # esl_print_info(self.esl_link)
-
-    def disconnect(self):
-        esl_close_connection(self.esl_link)
-
-    def configure(self):
-        esl_configure(
-            self.esl_link,
-            active_link=self.dsi_port,
-            speed=DSI_SETTINGS.LINK_SPEED,
-            mode=constants.ESL_LINK_MODE_NORMAL,
-            report=constants.ESL_ER_REPORT_PARITY_ERROR
-            | constants.ESL_ER_REPORT_TIME_CODE
-            | constants.ESL_ER_REPORT_ESC_EOP
-            | constants.ESL_ER_REPORT_ESC_EEP
-            | constants.ESL_ER_REPORT_ESC_ESC
-            | constants.ESL_ER_REPORT_TIMEOUT,
-        )
-
-        rmap_configure(
-            self.rmap_link,
-            target_key=constants.RMAP_TARGET_KEY,
-            initiator_logical_address=DSI_SETTINGS.INITIATOR_LOGICAL_ADDRESS,
-            target_logical_address=DSI_SETTINGS.TARGET_LOGICAL_ADDRESS,
-        )
-
-        # esl_print_summary_of_structure(self.esl_link)
-
-    def flush(self):
-        esl_flush(self.esl_link)
-
-    def send_timecode(self, timecode: int):
-        esl_send_timecode(self.esl_link, timecode)
-
-    def read_packet(self, timeout: int = None) -> Tuple[int, bytes]:
-        return esl_read_packet(self.esl_link, timeout=timeout)
-
-    def write_packet(self, packet: bytes):
-        esl_write_packet(self.esl_link, packet, len(packet), constants.ESL_EOP)
-
-    def read_register(self, address: int, length: int = 4, strict: bool = True) -> bytes:
-        terminator, rx_buffer = rmap_read_request(self.rmap_link, address, length)
-
-        packet = SpaceWirePacket.create_packet(rx_buffer)
-        rx_data = packet.data
-
-        return rx_data
-
-    def write_register(self, address: int, data: bytes):
-        terminator, rx_buffer = rmap_write_request(self.rmap_link, address, data)
-
-        # FIXME:
-        #  So, what do we need to do with the terminator value and the rx_buffer?
-        #  Is there some error checking needed here and what should than be the
-        #  return value?
-
-        return 0
-
-    def read_memory_map(self, address: int, size: int):
-        terminator, rx_buffer = rmap_read_request(self.rmap_link, address, size)
-
-        packet = SpaceWirePacket.create_packet(rx_buffer)
-        rx_data = packet.data
-
-        return rx_data

egse/dsi/spw_state.py

@@ -1,29 +0,0 @@
-class SpaceWireLinkState:
-    def __init__(self):
-        self.linkDisabled = True
-        self.linkStart    = False
-        self.autoStart    = False
-        self.gotNULL      = False
-
-    def isEnabled(self):
-        return not self.linkDisabled and (self.linkStart or self.autoStart and self.gotNULL)
-
-    def setAutoStart(self):
-        self.autoStart = True
-
-    def unsetAutoStart(self):
-        self.autoStart = False
-
-    def setGotNull(self):
-        self.gotNULL = True
-
-    def unsetGotNULL(self):
-        self.gotNULL = False
-
-    def setLinkDisabled(self):
-        self.linkDisabled = True
-
-    def unsetLinkDisabled(self):
-        self.linkDisabled = False
-
-    

egse/dummy.py

@@ -1,258 +0,0 @@
-"""
-This module provides dummy implementation for classes of the Commanding chain.
-"""
-import logging
-import pickle
-import random
-import sys
-
-import click
-import zmq
-
-from egse.command import ClientServerCommand
-from egse.control import ControlServer
-from egse.control import is_control_server_active
-from egse.decorators import dynamic_interface
-from egse.protocol import CommandProtocol
-from egse.proxy import Proxy
-from egse.settings import Settings
-from egse.system import AttributeDict
-from egse.system import format_datetime
-from egse.zmq_ser import bind_address
-from egse.zmq_ser import connect_address
-
-logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-LOGGER = logging.getLogger("egse.dummy")
-
-# Especially DummyCommand and DummyController need to be defined in a known module
-# because those objects are pickled and when de-pickled at the clients side the class
-# definition must be known.
-
-# We use AttributeDict here to define the settings, because that is how the Settings.load() returns
-# settings loaded from a YAML file.
-
-ctrl_settings = AttributeDict(
-    {
-        'HOSTNAME': 'localhost',
-        'COMMANDING_PORT': 4443,
-        'SERVICE_PORT': 4444,
-        'MONITORING_PORT': 4445,
-        'PROTOCOL': 'tcp',
-        'TIMEOUT': 10,
-        'HK_DELAY': 1.0,
-    }
-)
-
-commands = AttributeDict(
-    {
-        'info': {
-            'description': 'Info on the Dummy Controller',
-            'response': 'handle_device_method'
-        },
-        'response': {
-            'description': 'send a command to the device and return it\'s response',
-            'device_method': 'response',
-            'cmd': '{one} {two} {fake}',
-            'response': 'handle_device_method'
-        }
-    }
-)
-
-def is_dummy_cs_active():
-    return is_control_server_active(
-        endpoint=connect_address(ctrl_settings.PROTOCOL, ctrl_settings.HOSTNAME, ctrl_settings.COMMANDING_PORT)
-    )
-
-
-class DummyCommand(ClientServerCommand):
-    pass
-
-
-class DummyInterface:
-    @dynamic_interface
-    def info(self):
-        ...
-    @dynamic_interface
-    def response(self, *args, **kwargs):
-        ...
-
-
-class DummyProxy(Proxy, DummyInterface):
-    def __init__(self,
-                 protocol=ctrl_settings.PROTOCOL, hostname=ctrl_settings.HOSTNAME, port=ctrl_settings.COMMANDING_PORT):
-        """
-        Args:
-            protocol: the transport protocol [default is taken from settings file]
-            hostname: location of the control server (IP address) [default is taken from settings file]
-            port: TCP port on which the control server is listening for commands [default is taken from settings file]
-        """
-        super().__init__(connect_address(protocol, hostname, port), timeout=ctrl_settings.TIMEOUT)
-
-
-class DummyController(DummyInterface):
-    def info(self):
-        return "method info() called on DummyController"
-
-    def response(self, *args, **kwargs):
-        return f"response({args}, {kwargs})"
-
-
-class DummyProtocol(CommandProtocol):
-
-    def __init__(self, control_server: ControlServer):
-        super().__init__()
-        self.control_server = control_server
-
-        self.device_controller = DummyController()
-
-        self.load_commands(commands, DummyCommand, DummyController)
-
-        self.build_device_method_lookup_table(self.device_controller)
-
-        self._count = 0
-
-    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:
-
-        LOGGER.debug(f"Executing get_housekeeping function for {self.__class__.__name__}.")
-
-        self._count += 1
-
-        # use the sleep to test the responsiveness of the control server when even this get_housekeeping function takes
-        # a lot of time, i.e. up to several minutes in the case of data acquisition devices
-        # import time
-        # time.sleep(2.0)
-
-
-        return {
-            'timestamp': format_datetime(),
-            'COUNT': self._count,
-            'PI': 3.14159,  # just to have a constant parameter
-            'Random': random.randint(0, 100),  # just to have a variable parameter
-        }
-
-
-class DummyControlServer(ControlServer):
-    """
-    DummyControlServer - Command and monitor dummy device controllers.
-
-    The sever binds to the following ZeroMQ sockets:
-
-    * a REQ-REP socket that can be used as a command server. Any client can connect and
-      send a command to the dummy device controller.
-
-    * a PUB-SUP socket that serves as a monitoring server. It will send out status
-      information to all the connected clients every DELAY seconds.
-
-    """
-
-    def __init__(self):
-        super().__init__()
-
-        self.device_protocol = DummyProtocol(self)
-
-        self.logger.info(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.HK_DELAY)
-
-    def get_communication_protocol(self):
-        return 'tcp'
-
-    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):
-        return "DUMMY-HK"
-
-@click.group()
-def cli():
-    pass
-
-@click.group()
-def control_server():
-    pass
-
-cli.add_command(control_server)
-
-@control_server.command()
-def start():
-    """Start the dummy control server on localhost."""
-    from egse.dummy import DummyControlServer
-
-    try:
-        control_server = DummyControlServer()
-        control_server.serve()
-    except KeyboardInterrupt:
-        print("Shutdown requested...exiting")
-    except SystemExit as exit_code:
-        print("System Exit with code {}.".format(exit_code))
-        sys.exit(exit_code)
-    except Exception:
-        import traceback
-        traceback.print_exc(file=sys.stdout)
-
-@control_server.command()
-def stop():
-    """Send a quit service command to the dummy control server."""
-    with DummyProxy() as dummy:
-        sp = dummy.get_service_proxy()
-        sp.quit_server()
-
-
-@cli.command()
-@click.argument('hostname')
-@click.argument('port')
-@click.option('--pickle/--no-pickle', 'use_pickle', default=True)
-def monitoring(use_pickle: bool, hostname: str = 'localhost', port: int = None):
-    """Monitor the status of a control server on hostname.
-
-    The port number shall correspond to the port number on which the server is publishing
-    information with the ZeroMQ PUB-SUB protocol.
-
-    The response from the server (the data or string that was published) is logged at INFO level.
-
-    Arguments:
-
-        hostname: the IP address or hostname of the server
-
-        port: the port to connect to (this is the port to which the server binds)
-
-    Options:
-
-        --pickle or --no-pickle: use pickle to de-serialize the response
-    """
-    context = zmq.Context()
-
-    receiver = context.socket(zmq.SUB)
-    receiver.connect(f"tcp://{hostname}:{port}")
-    receiver.setsockopt_string(zmq.SUBSCRIBE, "")
-
-    while True:
-        try:
-            response = receiver.recv()
-            if use_pickle:
-                response = pickle.loads(response)
-
-            LOGGER.info(response)
-        except KeyboardInterrupt:
-            LOGGER.info("KeyboardInterrupt caught!")
-            break
-
-
-if __name__ == "__main__":
-    cli()

egse/dyndummy.py

@@ -1,179 +0,0 @@
-"""
-This module provides dummy implementation for classes of the Commanding chain.
-"""
-import logging
-import sys
-
-import click
-import zmq
-
-from egse.control import ControlServer
-from egse.device import DeviceTransport
-from egse.mixin import DynamicCommandMixin
-from egse.mixin import dynamic_command
-from egse.protocol import DynamicCommandProtocol
-from egse.proxy import DynamicProxy
-from egse.settings import Settings
-from egse.system import AttributeDict
-from egse.system import format_datetime
-from egse.zmq_ser import bind_address
-from egse.zmq_ser import connect_address
-
-logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-logger = logging.getLogger("egse.dyndummy")
-
-# We use AttributeDict here to define the settings, because that is how the Settings.load() returns
-# settings loaded from a YAML file.
-
-ctrl_settings = AttributeDict(
-    {
-        'HOSTNAME': 'localhost',
-        'COMMANDING_PORT': 5553,
-        'SERVICE_PORT': 5554,
-        'MONITORING_PORT': 5555,
-        'PROTOCOL': 'tcp'
-    }
-)
-
-
-class DummyDeviceInterface(DeviceTransport):
-    def __init__(self):
-        self._read_counter = 0
-        self._write_counter = 0
-        self._trans_counter = 0
-
-    def read(self) -> bytes:
-        self._read_counter += 1
-        logger.info(f"executing read() – [read count = {self._read_counter}]")
-        return f"read count = {self._read_counter}".encode()
-
-    def trans(self, command: str) -> bytes:
-        self._trans_counter += 1
-        logger.info(f"executing trans('{command}') – [trans count = {self._trans_counter}]")
-
-        self.write(command)
-        self.read()
-
-        return f"trans count = {self._trans_counter}".encode()
-
-    def write(self, command: str):
-        self._write_counter += 1
-        logger.info(f"executing write('{command}') – [write count = {self._write_counter}]")
-
-
-class DummyInterface:
-    @dynamic_command(cmd_type="query", cmd_string="INFO?")
-    def info(self) -> str:
-        """Return an info string from the device."""
-        raise NotImplementedError
-
-    @dynamic_command(cmd_type='transaction', cmd_string="RESPONSE:${msg}")
-    def response(self, msg: str) -> str:
-        """Return a response to the message sent."""
-        raise NotImplementedError
-
-
-class DummyController(DummyInterface, DynamicCommandMixin):
-    def __init__(self):
-        self.transport = DummyDeviceInterface()
-        super().__init__()
-
-
-class DummyProtocol(DynamicCommandProtocol):
-
-    def __init__(self, control_server: ControlServer):
-        super().__init__(control_server)
-        self.control_server = control_server
-
-        self.device_controller = DummyController()
-
-    def get_device(self):
-        return self.device_controller
-
-    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:
-        return {
-            'timestamp': format_datetime(),
-        }
-
-
-class DummyControlServer(ControlServer):
-    """
-    DummyControlServer - Command and monitor dummy device controllers.
-
-    The sever binds to the following ZeroMQ sockets:
-
-    * a REQ-REP socket that can be used as a command server. Any client can connect and
-      send a command to the dummy device controller.
-
-    * a PUB-SUP socket that serves as a monitoring server. It will send out status
-      information to all the connected clients every DELAY seconds.
-
-    """
-
-    def __init__(self):
-        super().__init__()
-
-        self.device_protocol = DummyProtocol(self)
-
-        self.logger.info(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)
-
-    def get_communication_protocol(self):
-        return 'tcp'
-
-    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
-
-
-class DummyProxy(DynamicProxy, DummyInterface):
-    def __init__(self,
-                 protocol=ctrl_settings.PROTOCOL, hostname=ctrl_settings.HOSTNAME, port=ctrl_settings.COMMANDING_PORT):
-        """
-        Args:
-            protocol: the transport protocol [default is taken from settings file]
-            hostname: location of the control server (IP address) [default is taken from settings file]
-            port: TCP port on which the control server is listening for commands [default is taken from settings file]
-        """
-        super().__init__(connect_address(protocol, hostname, port))
-
-
-@click.group()
-def cli():
-    pass
-
-
-@cli.command()
-def control_server():
-    """Start the dummy control server on localhost."""
-    from egse.dyndummy import DummyControlServer
-
-    try:
-        control_server = DummyControlServer()
-        control_server.serve()
-    except KeyboardInterrupt:
-        print("Shutdown requested...exiting")
-    except SystemExit as exit_code:
-        print(f"System Exit with code ({exit_code})")
-        sys.exit(exit_code)
-    except Exception:
-        import traceback
-        traceback.print_exc(file=sys.stdout)
-
-
-if __name__ == "__main__":
-    cli()