ariel-tcu 0.17.0__py3-none-any.whl

egse/ariel/tcu/tcu_cs.py

@@ -0,0 +1,246 @@
+"""Control Server for the Ariel Telescope Control Unit (TCU)."""
+
+import multiprocessing
+import logging
+import sys
+from typing import Annotated
+
+import zmq
+import typer
+import rich
+
+from egse.ariel.tcu import (
+    COMMANDING_PORT,
+    HOSTNAME,
+    PROTOCOL,
+    SERVICE_PORT,
+    MONITORING_PORT,
+    STORAGE_MNEMONIC,
+    PROCESS_NAME,
+    SERVICE_TYPE,
+)
+from egse.control import is_control_server_active, ControlServer
+from egse.registry.client import RegistryClient
+from egse.services import ServiceProxy
+from egse.storage import store_housekeeping_information
+from egse.zmq_ser import connect_address, get_port_number
+from egse.ariel.tcu.tcu_protocol import TcuProtocol
+from egse.ariel.tcu.tcu import TcuProxy
+
+logger = logging.getLogger("egse.ariel.tcu")
+
+
+def is_tcu_cs_active(timeout: float = 0.5) -> bool:
+    """Checks whether the Ariel TCU Control Server is running.
+
+    Args:
+        timeout (float): Timeout when waiting for a reply [s].
+
+    Returns:
+        True if the Ariel TCU Control Server is running and replied with the expected answer; False otherwise.
+    """
+
+    endpoint = connect_address(PROTOCOL, HOSTNAME, COMMANDING_PORT)
+
+    return is_control_server_active(endpoint, timeout)
+
+
+class TcuControlServer(ControlServer):
+    def __init__(self, simulator: bool = False):
+        super().__init__()
+
+        multiprocessing.current_process().name = PROCESS_NAME
+
+        self.logger = logger
+        self.service_name = PROCESS_NAME
+        self.service_type = SERVICE_TYPE
+
+        self.device_protocol = TcuProtocol(self, simulator=simulator)
+
+        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.register_service(SERVICE_TYPE)
+
+    def get_communication_protocol(self) -> str:
+        """Returns the communication protocol used by the Ariel TCU Control Server.
+
+        Returns:
+            Communication protocol used by the Ariel TCU Control Server, as specified in the settings.
+        """
+
+        return PROTOCOL
+
+    def get_commanding_port(self) -> int:
+        """Returns the commanding port used by the Ariel TCU Control Server.
+
+        Returns:
+            Commanding port used by the Ariel TCU Control Server, as specified in the settings.
+        """
+
+        return get_port_number(self.dev_ctrl_cmd_sock) or COMMANDING_PORT
+
+    def get_service_port(self) -> int:
+        """Returns the service port used by the Ariel TCU Control Server.
+
+        Returns:
+            Service port used by the Ariel TCU Control Server, as specified in the settings.
+        """
+
+        return get_port_number(self.dev_ctrl_service_sock) or SERVICE_PORT
+
+    def get_monitoring_port(self) -> int:
+        """Returns the monitoring port used by the Ariel TCU Control Server.
+
+        Returns:
+            Monitoring port used by the Ariel TCU Control Server, as specified in the settings.
+        """
+
+        return get_port_number(self.dev_ctrl_mon_sock) or MONITORING_PORT
+
+    def get_storage_mnemonic(self) -> str:
+        """Returns the storage mnemonic used by the Ariel TCU Control Server.
+
+        Returns:
+            Storage mnemonic used by the Ariel TCU Control Server, as specified in the settings.
+        """
+
+        return STORAGE_MNEMONIC
+
+    def is_storage_manager_active(self):
+        """Checks whether the Storage Manager is active."""
+        from egse.storage import is_storage_manager_active
+
+        return is_storage_manager_active()
+
+    def store_housekeeping_information(self, data):
+        """Sends housekeeping information of the Ariel TCU to the Storage Manager."""
+
+        origin = self.get_storage_mnemonic()
+        store_housekeeping_information(origin, data)
+
+    def register_to_storage_manager(self):
+        from egse.storage import register_to_storage_manager
+        from egse.storage.persistence import TYPES
+
+        register_to_storage_manager(
+            origin=self.get_storage_mnemonic(),
+            persistence_class=TYPES["CSV"],
+            prep={
+                "column_names": list(self.device_protocol.get_housekeeping().keys()),
+                "mode": "a",
+            },
+        )
+
+    def unregister_from_storage_manager(self):
+        from egse.storage import unregister_from_storage_manager
+
+        unregister_from_storage_manager(origin=self.get_storage_mnemonic())
+
+    # def before_serve(self):
+    #     start_http_server(CTRL_SETTINGS.METRICS_PORT)
+
+    def after_serve(self):
+        self.deregister_service()
+
+
+app = typer.Typer()
+
+
+@app.command()
+def start(
+    simulator: Annotated[
+        bool, typer.Option("--simulator", "--sim", help="start the Ariel TCU Control Server in simulator mode")
+    ] = False,
+):
+    """Starts the Ariel TCU Control Server."""
+
+    try:
+        controller = TcuControlServer(simulator)
+        controller.serve()
+    except KeyboardInterrupt:
+        print("Shutdown requested...exiting")
+    except SystemExit as exc:
+        exit_code = exc.code if hasattr(exc, "code") else 0
+        print(f"System Exit with code {exc.code}")
+        sys.exit(exit_code)
+    except Exception:
+        logger.exception("Cannot start the Ariel TCU 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
+
+
+@app.command()
+def stop():
+    """Sends a `quit_server` command to the Ariel TCU Control Server."""
+
+    with RegistryClient() as reg:
+        service = reg.discover_service(SERVICE_TYPE)
+        rich.print("service = ", service)
+
+        if service:
+            proxy = ServiceProxy(protocol="tcp", hostname=service["host"], port=service["metadata"]["service_port"])
+            proxy.quit_server()
+        else:
+            # *_, device_type, controller_type = get_hexapod_controller_pars(device_id)
+
+            try:
+                with TcuProxy() as tcu_proxy:
+                    with tcu_proxy.get_service_proxy() as sp:
+                        sp.quit_server()
+            except ConnectionError:
+                rich.print("[red]Couldn't connect to 'tcu_cs', process probably not running. ")
+
+
+@app.command()
+def status():
+    """Requests the status information from the Ariel TCU Control Server."""
+
+    with RegistryClient() as reg:
+        service = reg.discover_service(SERVICE_TYPE)
+
+        if service:
+            protocol = service.get("protocol", "tcp")
+            hostname = service["host"]
+            port = service["port"]
+            service_port = service["metadata"]["service_port"]
+            monitoring_port = service["metadata"]["monitoring_port"]
+            endpoint = connect_address(protocol, hostname, port)
+        else:
+            rich.print(
+                f"[red]The Ariel TCU Control Server isn't registered as a service. The Control Server cannot be "
+                f"contacted without the required information from the service registry.[/]"
+            )
+            rich.print("Ariel TCU: [red]not active")
+            return
+
+    if is_control_server_active(endpoint):
+        rich.print("Ariel TCU: [green]active")
+
+        with TcuProxy() as tcu:
+            sim = tcu.is_simulator()
+            connected = tcu.is_connected()
+            ip = tcu.get_ip_address()
+            rich.print(f"mode: {'simulator' if sim else 'device'}{'' if connected else ' not'} connected")
+            rich.print(f"hostname: {ip}")
+            rich.print(f"commanding port: {port}")
+            rich.print(f"service port: {service_port}")
+            rich.print(f"monitoring port: {monitoring_port}")
+    else:
+        rich.print("Ariel TCU: [red]not active")
+
+
+if __name__ == "__main__":
+    import logging
+
+    from egse.logger import set_all_logger_levels
+
+    set_all_logger_levels(logging.DEBUG)
+
+    sys.exit(app())

egse/ariel/tcu/tcu_devif.py

@@ -0,0 +1,104 @@
+"""Device connection interface for the Ariel Telescope Control Unit (TCU)."""
+
+import logging
+import time
+
+import serial
+
+from egse.device import DeviceConnectionInterface, DeviceTransport
+from egse.settings import Settings
+
+logger = logging.getLogger(__name__)
+DEVICE_SETTINGS = Settings.load("Ariel TCU Controller")
+
+
+class TcuError(Exception):
+    """Generic TCU error for low-level classes."""
+
+    pass
+
+
+class TcuDeviceInterface(DeviceConnectionInterface, DeviceTransport):
+    """Defines the low-level interface to the Ariel TCU (Arduino)."""
+
+    def __init__(self, port: int = None):
+        """Initialisation of a serial interface to the TCU Arduino.
+
+        Args:
+            port (int): Serial port to which to connect to the TCU Arduino.
+        """
+
+        super().__init__()
+
+        # self.hostname = hostname or DEVICE_SETTINGS["HOSTNAME"]
+        self.port = port or DEVICE_SETTINGS["COM_PORT"]
+
+        self.arduino = serial.Serial()
+        self.arduino.port = self.port
+        self.arduino.baudrate = DEVICE_SETTINGS["BAUD_RATE"]
+        self.arduino.bytesize = DEVICE_SETTINGS["NUM_DATA_BITS"]
+        self.arduino.parity = DEVICE_SETTINGS["PARITY"]
+        self.arduino.stopbits = DEVICE_SETTINGS["NUM_STOP_BITS"]
+
+    def connect(self) -> None:
+        """Opens the serial port to the TCU Arduino.
+
+        Raises:
+            TcuError: When the serial port could not be opened.
+        """
+
+        if self.is_connected():
+            raise TcuError("TCU already connected.")
+        # if self.hostname in (None, ""):
+        #     raise TcuError("TCU hostname is not initialised.")
+        if self.port in (None, 0):
+            raise TcuError("TCU serial port is not initialised.")
+
+        try:
+            self.arduino.open()
+        except Exception as exc:
+            raise TcuError(f"Failed to open TCU serial port {self.port}") from exc
+
+    def disconnect(self) -> None:
+        """Closes the serial port to the TCU Arduino.
+
+        Raises:
+            TcuError: When the serial port could not be closed.
+        """
+
+        try:
+            self.arduino.close()
+        except Exception as exc:
+            raise TcuError(f"Failed to close TCU serial port {self.port}") from exc
+
+    def reconnect(self) -> None:
+        """Re-connects to the Ariel TCU Arduino."""
+
+        if self.is_connected():
+            self.disconnect()
+        self.connect()
+
+    def is_connected(self) -> bool:
+        """Checks whether the serial port to the TCU Arduino is open.
+
+        Returns:
+            True if the serial port to the TCU Arduino is open; False otherwise.
+        """
+
+        return self.arduino.is_open
+
+    def trans(self, command: str) -> bytes:
+        """Sends the given command to the TCU Arduino and returns the response.
+
+        This is seen as a transaction.
+
+        Args:
+            command: Command string to send to the TCU Arduino.
+
+        Returns:
+            Response string from the TCU Arduino.
+        """
+
+        self.arduino.write(command.encode("utf-8"))
+        time.sleep(0.05)
+        return self.arduino.readline()

egse/ariel/tcu/tcu_protocol.py

@@ -0,0 +1,147 @@
+"""Command protocol for the Ariel Telescope Control Unit (TCU)."""
+
+import logging
+from pathlib import Path
+
+from egse.ariel.tcu import NUM_TSM_PROBES_PER_FRAME
+from egse.ariel.tcu.tcu import TcuController, TcuSimulator, TcuInterface
+from egse.command import ClientServerCommand
+from egse.control import ControlServer
+from egse.device import DeviceConnectionState
+from egse.protocol import DynamicCommandProtocol
+from egse.settings import Settings
+from egse.system import format_datetime
+from egse.zmq_ser import bind_address
+
+_HERE = Path(__file__).parent
+DEVICE_SETTINGS = Settings.load(filename="tcu.yaml", location=_HERE)
+logger = logging.getLogger("egse.ariel.tcu")
+
+
+class TcuCommand(ClientServerCommand):
+    """Command class for the Ariel TCU Control Server."""
+
+    pass
+
+
+class TcuProtocol(DynamicCommandProtocol):
+    """Command protocol for the Ariel TCU Control Server."""
+
+    def __init__(self, control_server: ControlServer, simulator: bool = False):
+        """Initialisation of an Ariel TCU protocol.
+
+        Args:
+            control_server (ControlServer): Ariel TCU Control Server.
+            simulator (bool): Whether to use a simulator as the backend.
+        """
+
+        super().__init__(control_server)
+
+        self.simulator = simulator
+
+        if self.simulator:
+            self.tcu = TcuSimulator()
+        else:
+            self.tcu = TcuController()
+
+        try:
+            self.tcu.connect()
+        except ConnectionError:
+            logger.warning("Couldn't establish connection to the Ariel TCU, check the log messages.")
+
+        # self.metrics = define_metrics("TCU")
+
+    def get_bind_address(self) -> str:
+        """Returns the bind address for the Ariel TCU Control Server.
+
+        Returns:
+            Bind address for the Ariel TCU Control Server.
+        """
+
+        return bind_address(self.control_server.get_communication_protocol(), self.control_server.get_commanding_port())
+
+    def get_device(self) -> TcuInterface:
+        """Returns the Ariel TCU interface.
+
+        Returns:
+            Ariel TCU interface.
+        """
+        return self.tcu
+
+    def get_status(self) -> dict:
+        """Returns the status information for the Ariel TCU Control Server.
+
+        Returns:
+            Status information for the Ariel TCU Control Server.
+        """
+
+        status = super().get_status()
+
+        if self.state == DeviceConnectionState.DEVICE_NOT_CONNECTED and not self.simulator:
+            return status
+
+        # TODO Add device-specific status information
+
+        return status
+
+    def get_housekeeping(self) -> dict:
+        """Returns the housekeeping information for the Ariel TCU Control Server.
+
+        Returns:
+            Housekeeping information for the Ariel TCU Control Server.
+        """
+
+        result = dict()
+        result["timestamp"] = format_datetime()
+
+        if self.state == DeviceConnectionState.DEVICE_NOT_CONNECTED and not self.simulator:
+            return result
+
+        result["TCU_MODE"] = self.tcu.get_tcu_mode()
+        result["TCU_VHK_PSU_VMOTOR"] = self.tcu.vhk_psu_vmotor()
+        result["TCU_VHK_PSU_VHI"] = self.tcu.vhk_psu_vhi()
+        result["TCU_VHK_PSU_VLOW"] = self.tcu.vhk_psu_vlow()
+        result["TCU_VHK_PSU_VMEDP"] = self.tcu.vhk_psu_vmedp()
+        result["TCU_VHK_PSU_VMEDN"] = self.tcu.vhk_psu_vmedn()
+        result["TCU_IHK_PSU_VMEDN"] = self.tcu.ihk_psu_vmedn()
+        result["TCU_IHK_PSU_VMEDP"] = self.tcu.ihk_psu_vmedp()
+        result["TCU_IHK_PSU_VLOW"] = self.tcu.ihk_psu_vlow()
+        result["TCU_IHK_PSU_VHI"] = self.tcu.ihk_psu_vhi()
+        result["TCU_IHK_PSU_VMOTOR"] = self.tcu.ihk_psu_vmotor()
+        result["TCU_THK_PSU_FIRST"] = self.tcu.thk_psu_first()
+        result["TCU_THK_M2MD_FIRST"] = self.tcu.thk_m2md_first()
+        result["TCU_THK_PSU_SECOND"] = self.tcu.thk_psu_second()
+        result["TCU_THK_M2MD_SECOND"] = self.tcu.thk_m2md_second()
+        result["TCU_THK_CTS_Q1"] = self.tcu.thk_cts_q1()
+        result["TCU_THK_CTS_Q2"] = self.tcu.thk_cts_q2()
+        result["TCU_THK_CTS_Q3"] = self.tcu.thk_cts_q3()
+        result["TCU_THK_CTS_Q4"] = self.tcu.thk_cts_q4()
+        result["TCU_THK_CTS_FPGA"] = self.tcu.thk_cts_fpga()
+        result["TCU_THK_CTS_ADS1282"] = self.tcu.thk_cts_ads1282()
+        result["TCU_VHK_THS_RET"] = self.tcu.vhk_ths_ret()
+        result["TCU_HK_ACQ_COUNTER"] = self.tcu.hk_acq_counter()
+
+        for probe in range(1, NUM_TSM_PROBES_PER_FRAME + 1):
+            bias_pos = self.tcu.tsm_adc_value_xx_biasp(probe=probe)
+            result[f"TCU_BIAS_POS_PROBE_{probe}"] = bias_pos
+            bias_neg = self.tcu.tsm_adc_value_xx_biasn(probe=probe)
+            result[f"TCU_BIAS_NEG_PROBE_{probe}"] = bias_neg
+            current_pos = self.tcu.tsm_adc_value_xx_currentp(probe=probe)
+            result[f"TCU_CURRENT_POS_PROBE_{probe}"] = current_pos
+            current_neg = self.tcu.tsm_adc_value_xx_currentn(probe=probe)
+            result[f"TCU_CURRENT_NEG_PROBE_{probe}"] = current_neg
+
+            # alpha = (bias_pos - bias_neg) / (current_pos - current_neg)
+            # (c0, c1) ??
+            # resistance = alpha / (alpha * c1 + c0)
+
+        return result
+
+    def is_device_connected(self) -> bool:
+        """Checks whether the Ariel TCU is connected.
+
+        Returns:
+            True if the Ariel TCU is connected; False otherwise.
+        """
+
+        return self.tcu.is_connected()