ariel-tcu 0.17.3__py3-none-any.whl → 0.18.0__py3-none-any.whl

egse/ariel/tcu/tcu_cmd_utils.py

@@ -11,7 +11,7 @@ Reference documents:
     - RD02: ARIEL TCU Data Handling (ARIEL-IEEC-PL-TN-007), v1.0
     - RD03: TCU code provided by Vladimiro Noce (priv. comm.)
     - RD04: ARIEL Telescope Control Unit Design Description Document (ARIEL-IEEC-PL-DD-001), v1.10
-    - RD05: ARIEL TCU FW Architecture Design(ARIEL-IEEC-PL-DD-002), v1.5
+    - RD05: ARIEL TCU FW Architecture Design (ARIEL-IEEC-PL-DD-002), v1.5
 """
 
 from enum import StrEnum
@@ -263,7 +263,7 @@ def _create_write_cmd_string(
 
     Note that this function should not be called directly in the `@dynamic_command` decorator (in the `cmd_string`
     attribute), as this will increase the transaction identifier without actually calling the function (merely
-    importing the interface in which such a decorator call is made will increase the transaction identifier)..
+    importing the interface in which such a decorator call is made will increase the transaction identifier).
 
     Args:
         cmd_address (CommandAddress | str | int): Identifier of the commanded device.
@@ -289,7 +289,7 @@ def _create_read_cmd_string(
 
     Note that this function should not be called directly in the `@dynamic_command` decorator (in the `cmd_string`
     attribute), as this will increase the transaction identifier without actually calling the function (merely
-    importing the interface in which such a decorator call is made will increase the transaction identifier)..
+    importing the interface in which such a decorator call is made will increase the transaction identifier)>
 
     Args:
         cmd_address (CommandAddress | str | int): Identifier of the commanded device.
@@ -327,7 +327,8 @@ def _create_cmd_string(
             - 0001: M2MD axis-1 commands;
             - 0002: M2MD axis-2 commands;
             - 0003: M2MD axis-3 commands;
-            - 0020: TSM commands;
+            - 0004: TSM commands;
+            - 0005: HK commands
         - BBBB: Command identifier, internal to the commanded device;
         - CCCC: First 16-bit cargo word;
         - DDDD: Second 16-bit cargo word;
@@ -335,7 +336,7 @@ def _create_cmd_string(
 
     Note that this function should not be called directly in the `@dynamic_command` decorator (in the `cmd_string`
     attribute), as this will increase the transaction identifier without actually calling the function (merely
-    importing the interface in which such a decorator call is made will increase the transaction identifier)..
+    importing the interface in which such a decorator call is made will increase the transaction identifier).
 
     Args:
         packet_type (PacketType): Type of the packet (read or write).
@@ -792,18 +793,18 @@ def get_prof_gen_axis_speed(axis: CommandAddress | str | int) -> str:
     return _create_read_cmd_string(axis, M2MDCommandIdentifier.PROF_GEN_AXIS_SPEED)
 
 
-def set_prof_gen_axis_speed(axis: CommandAddress | str | int, cargo2: int = 0x1777) -> str:
+def set_prof_gen_axis_speed(axis: CommandAddress | str | int, speed: int = 0x1777) -> str:
     """Builds the command string for the M2MD PROF_GEN_AXIS_SPEED write command.
 
     Args:
         axis (CommandAddress | str | int): Axis to which the command is sent.
-        cargo2 (int): Cargo 2 part of the command string.
+        speed (int): Cargo 2 part of the command string.
 
     Returns:
         Command string for the M2MD PROF_GEN_AXIS_SPEED write command.
     """
 
-    return _create_write_cmd_string(axis, M2MDCommandIdentifier.PROF_GEN_AXIS_SPEED, cargo2=cargo2)
+    return _create_write_cmd_string(axis, M2MDCommandIdentifier.PROF_GEN_AXIS_SPEED, cargo2=speed)
 
 
 def get_prof_gen_axis_state_start(axis: CommandAddress | str | int) -> str:
@@ -1387,3 +1388,59 @@ def hk_acq_counter() -> str:
     """
 
     return _create_read_cmd_string(CommandAddress.HK, HKCommandIdentifier.HK_ACQ_COUNTER)
+
+
+def general_cmd():
+    """Decorator for general TCU commands.
+
+    This is used to decorate these commands in the TcuInterface class, to enable an easier identification of the
+    component of the TCU that the command is for (which is necessary in the TCU UI).
+    """
+
+    def decorator(func):
+        func.target_comp = "GENERAL"
+        return func
+
+    return decorator
+
+
+def m2md_cmd():
+    """Decorator for M2MD commands.
+
+    This is used to decorate these commands in the TcuInterface class, to enable an easier identification of the
+    component of the TCU that the command is for (which is necessary in the TCU UI).
+    """
+
+    def decorator(func):
+        func.target_comp = "M2MD"
+        return func
+
+    return decorator
+
+
+def tsm_cmd():
+    """Decorator for TSM commands.
+
+    This is used to decorate these commands in the TcuInterface class, to enable an easier identification of the
+    component of the TCU that the command is for (which is necessary in the TCU UI).
+    """
+
+    def decorator(func):
+        func.target_comp = "TSM"
+        return func
+
+    return decorator
+
+
+def hk_cmd():
+    """Decorator for HK commands.
+
+    This is used to decorate these commands in the TcuInterface class, to enable an easier identification of the
+    component of the TCU that the command is for (which is necessary in the TCU UI).
+    """
+
+    def decorator(func):
+        func.target_comp = "HK"
+        return func
+
+    return decorator

egse/ariel/tcu/tcu_cs.py

@@ -1,13 +1,13 @@
 """Control Server for the Ariel Telescope Control Unit (TCU)."""
 
-import multiprocessing
 import logging
-import sys
+import multiprocessing
 from typing import Annotated
 
-import zmq
-import typer
 import rich
+import sys
+import typer
+import zmq
 
 from egse.ariel.tcu import (
     COMMANDING_PORT,
@@ -19,13 +19,13 @@ from egse.ariel.tcu import (
     PROCESS_NAME,
     SERVICE_TYPE,
 )
+from egse.ariel.tcu.tcu import TcuProxy
+from egse.ariel.tcu.tcu_protocol import TcuProtocol
 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")
 
@@ -40,13 +40,37 @@ def is_tcu_cs_active(timeout: float = 0.5) -> bool:
         True if the Ariel TCU Control Server is running and replied with the expected answer; False otherwise.
     """
 
-    endpoint = connect_address(PROTOCOL, HOSTNAME, COMMANDING_PORT)
+    if COMMANDING_PORT != 0:
+        protocol = PROTOCOL
+        hostname = HOSTNAME
+        port = COMMANDING_PORT
+
+    else:
+        with RegistryClient() as reg:
+            service = reg.discover_service(SERVICE_TYPE)
+
+            if service:
+                protocol = service.get("protocol", "tcp")
+                hostname = service["host"]
+                port = service["port"]
+
+            else:
+                return False
+
+    # noinspection PyUnboundLocalVariable
+    endpoint = connect_address(protocol, hostname, port)
 
     return is_control_server_active(endpoint, timeout)
 
 
 class TcuControlServer(ControlServer):
     def __init__(self, simulator: bool = False):
+        """Initialisation of an Ariel TCU Control Server.
+
+        Args:
+            simulator (bool): Indicates whether to operate in simulator mode.
+        """
+
         super().__init__()
 
         multiprocessing.current_process().name = PROCESS_NAME
@@ -158,6 +182,7 @@ def start(
 ):
     """Starts the Ariel TCU Control Server."""
 
+    # noinspection PyBroadException
     try:
         controller = TcuControlServer(simulator)
         controller.serve()
@@ -169,9 +194,6 @@ def start(
         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
 
@@ -182,14 +204,11 @@ def stop():
 
     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:
@@ -202,26 +221,34 @@ def stop():
 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 COMMANDING_PORT != 0:
+        endpoint = connect_address(PROTOCOL, HOSTNAME, COMMANDING_PORT)
+        port = COMMANDING_PORT
+        service_port = SERVICE_PORT
+        monitoring_port = MONITORING_PORT
 
-    if is_control_server_active(endpoint):
-        rich.print("Ariel TCU: [green]active")
+    else:
+        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
+
+    # noinspection PyUnboundLocalVariable
+    if is_control_server_active(endpoint, timeout=2):
+        rich.print(f"Ariel TCU: [green]active -> {endpoint}")
 
         with TcuProxy() as tcu:
             sim = tcu.is_simulator()
@@ -229,8 +256,11 @@ def status():
             ip = tcu.get_ip_address()
             rich.print(f"mode: {'simulator' if sim else 'device'}{'' if connected else ' not'} connected")
             rich.print(f"hostname: {ip}")
+            # noinspection PyUnboundLocalVariable
             rich.print(f"commanding port: {port}")
+            # noinspection PyUnboundLocalVariable
             rich.print(f"service port: {service_port}")
+            # noinspection PyUnboundLocalVariable
             rich.print(f"monitoring port: {monitoring_port}")
     else:
         rich.print("Ariel TCU: [red]not active")

egse/ariel/tcu/tcu_devif.py

@@ -11,6 +11,8 @@ from egse.settings import Settings
 logger = logging.getLogger(__name__)
 DEVICE_SETTINGS = Settings.load("Ariel TCU Controller")
 
+EXPECTED_TRANSACTION_ID = -1
+
 
 class TcuError(Exception):
     """Generic TCU error for low-level classes."""
@@ -102,3 +104,28 @@ class TcuDeviceInterface(DeviceConnectionInterface, DeviceTransport):
         self.arduino.write(command.encode("utf-8"))
         time.sleep(0.05)
         return self.arduino.readline()
+
+
+class TcuHexInterface(DeviceTransport):
+    """Transport class to generate the hex strings that are sent to the TCU."""
+
+    def trans(self, command: str) -> bytes:
+        """Returns the given command string as bytes.
+
+        This can be used to:
+
+            - Test whether the command string is built correctly (and the transaction identifier is incremented for
+              each command call);
+            - Generate the hex string that is sent to the TCU, such that it can be displayed in the TCU UI.
+
+        Args:
+            command (str): Command string to encode.
+
+        Returns:
+            Encoded command string.
+        """
+
+        global EXPECTED_TRANSACTION_ID
+        EXPECTED_TRANSACTION_ID += 1
+
+        return command.encode()

egse/ariel/tcu/tcu_protocol.py

@@ -15,7 +15,7 @@ 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")
+LOGGER = logging.getLogger("egse.ariel.tcu")
 
 
 class TcuCommand(ClientServerCommand):
@@ -47,7 +47,7 @@ class TcuProtocol(DynamicCommandProtocol):
         try:
             self.tcu.connect()
         except ConnectionError:
-            logger.warning("Couldn't establish connection to the Ariel TCU, check the log messages.")
+            LOGGER.warning("Couldn't establish connection to the Ariel TCU, check the log messages.")
 
         # self.metrics = define_metrics("TCU")