uphy-device 0.1.0.dev2794__tar.gz

uphy_device-0.1.0.dev2794/LICENSE.txt

@@ -0,0 +1,5 @@
+Copyright rt-labs AB, Sweden.
+All rights reserved.
+
+You may not use this software in a commercial product without
+purchasing a license. Contact sales@rt-labs.com for more information.

uphy_device-0.1.0.dev2794/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.1
+Name: uphy-device
+Version: 0.1.0.dev2794
+Author-email: RT-Labs <support@rt-labs.com>
+License: Copyright rt-labs AB, Sweden.
+        All rights reserved.
+        
+        You may not use this software in a commercial product without
+        purchasing a license. Contact sales@rt-labs.com for more information.
+        
+Project-URL: RT-Labs, https://rt-labs.com
+Project-URL: U-Phy, https://rt-labs.com/u-phy
+Project-URL: Documentation, https://docs.rt-labs.com/u-phy
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: yarl>=1.15.2
+Requires-Dist: typer>=0.12.5
+Requires-Dist: rich>=13.9.2
+Requires-Dist: dearpygui>=2.0.0
+Requires-Dist: uphy-upgen>=0.1.0
+Requires-Dist: yarl>=1.12.1
+Requires-Dist: pyserial>=3.5
+Requires-Dist: psutil>=6.1.0
+Requires-Dist: zeroconf>=0.136.0
+
+# U-Phy Device Tools
+
+## Introduction
+
+U-Phy Device tools support controlling and executing a U-Phy server to simulation and run a fieldbus device inside a python program.
+
+See documentation at [https://docs.rt-labs.com/u-phy](https://docs.rt-labs.com/u-phy)

uphy_device-0.1.0.dev2794/README.md

@@ -0,0 +1,7 @@
+# U-Phy Device Tools
+
+## Introduction
+
+U-Phy Device tools support controlling and executing a U-Phy server to simulation and run a fieldbus device inside a python program.
+
+See documentation at [https://docs.rt-labs.com/u-phy](https://docs.rt-labs.com/u-phy)

uphy_device-0.1.0.dev2794/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools", "wheel", "Cython"]
+
+[project]
+name="uphy-device"
+version="0.1.0.dev2794"
+authors = [
+    {name="RT-Labs", email="support@rt-labs.com"}
+]
+requires-python = ">= 3.10"
+
+license = {file = "LICENSE.txt"}
+readme = "README.md"
+
+dependencies = [
+    "yarl>=1.15.2",
+    "typer>=0.12.5",
+    "rich>=13.9.2",
+    "dearpygui>=2.0.0",
+    "uphy-upgen>=0.1.0",
+    "yarl>=1.12.1",
+    "pyserial>=3.5",
+    "psutil>=6.1.0",
+    "zeroconf>=0.136.0",
+]
+
+[project.urls]
+RT-Labs = "https://rt-labs.com"
+U-Phy = "https://rt-labs.com/u-phy"
+Documentation  = "https://docs.rt-labs.com/u-phy"
+
+[project.scripts]
+uphy-device = "uphy.device.__main__:app"
+
+
+[tool.uv]
+dev-dependencies = [
+    "ruff>=0.6.8",
+]
+
+[project.entry-points.'uphy.cli']
+device = 'uphy.device.__main__:app'

uphy_device-0.1.0.dev2794/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

uphy_device-0.1.0.dev2794/setup.py

@@ -0,0 +1,77 @@
+# setup.py
+
+from setuptools import setup, Extension
+from Cython.Build import cythonize
+from pathlib import Path
+import os
+import sys
+import shutil
+import logging
+
+
+# Copy the uphy install into package data
+package_data = {}
+if prefix := os.environ.get("LIBUPHY_INSTALL_PATH", None):
+    target = Path("uphy/device/server/bin")
+    shutil.rmtree(target, ignore_errors=True)
+    shutil.copytree(Path(prefix) / "bin", target)
+    package_data["uphy.device.server"] = [
+        str(file.relative_to("uphy/device/server")) for file in target.rglob("*")
+    ]
+
+    target = Path("uphy/device/share")
+    shutil.rmtree(target, ignore_errors=True)
+    shutil.copytree(Path(prefix) / "share" / "uphy", target)
+    package_data["uphy.device"] = [
+        str(file.relative_to("uphy/device")) for file in target.rglob("*")
+    ]
+else:
+    logging.error("LIBUPHY_INSTALL_PATH not specified")
+    exit(-1)
+
+include_dirs = [f"{prefix}/include", "src"]
+library_dirs = [f"{prefix}/lib"]
+libraries = ["uphy", "erpc", "osal", "upi-host"]
+
+if sys.platform == "win32":
+    libraries.extend(["wsock32", "ws2_32", "winmm"])
+    server_name = "server.exe"
+else:
+    server_name = "server"
+
+extensions = [
+    Extension(
+        name="uphy.device.api",
+        sources=["uphy/device/api/*.pyx"],
+        include_dirs=include_dirs,
+        libraries=libraries,
+        library_dirs=library_dirs,
+        language="c++",
+    ),
+]
+
+packages = [
+    "uphy.device",
+    "uphy.device.api",
+    "uphy.device.gui",
+    "uphy.device.server",
+]
+
+package_data["uphy.device.api"] = ["__init__.pyx", "__init__.pxd"]
+
+setup(
+    packages=packages,
+    package_data=package_data,
+    include_package_data=True,
+    ext_modules=cythonize(
+        extensions,
+        gdb_debug=True,
+        language_level="3",
+        compiler_directives={
+            "c_string_type": "bytes",
+            "c_string_encoding": "utf-8",
+            "embedsignature": "true",
+            "embedsignature.format": "python",
+        },
+    ),
+)

uphy_device-0.1.0.dev2794/uphy/device/__init__.py

@@ -0,0 +1,251 @@
+from collections.abc import Generator
+from contextlib import contextmanager
+from functools import partial
+import importlib
+from threading import Thread
+import time
+from typing import Optional
+from uphy.device.api import (
+    Up,
+    ApiError,
+    Device,
+    SignalInfos,
+    ProfinetConfig,
+    EthercatDevice,
+    ModbusDevice,
+)
+from yarl import URL
+import logging
+from time import sleep
+from .server import server_binary
+from .gui import Gui, GuiExit, UpdateProtocol
+import subprocess
+from abc import ABC, abstractmethod
+
+from uphy.device import api
+import upgen.model.uphy as uphy_model
+from enum import Enum
+import importlib.util
+import importlib.resources
+import sys
+
+LOGGER = logging.getLogger(__name__)
+
+
+class Protocol(str, Enum):
+    ETHERCAT = "ethercat"
+    PROFINET = "profinet"
+    MODBUS = "modbus"
+
+
+class DeviceError(Exception):
+    pass
+
+
+class UnsupportedError(DeviceError):
+    pass
+
+
+class DeviceHandlerBase(Up, ABC):
+    _update: UpdateProtocol
+    _status: str
+
+    def __init__(
+        self,
+        device: Device,
+        vars: SignalInfos,
+        busconf: ProfinetConfig | EthercatDevice | ModbusDevice,
+    ):
+        LOGGER.debug(device)
+        LOGGER.debug(vars)
+        LOGGER.debug(busconf)
+
+        super().__init__(device=device, vars=vars, busconf=busconf)
+        self._init()
+
+    def set_update_callback(self, update: UpdateProtocol):
+        self._update = update
+
+    @contextmanager
+    def gui(self, gui_arg: Gui) -> Generator[None, None, None]:
+        with gui.get(gui_arg, self.device) as update:
+            self.set_update_callback(update)
+            yield
+
+    @abstractmethod
+    def _init():
+        """Handler started"""
+        pass
+
+    @abstractmethod
+    def _set_outputs():
+        """System initialized."""
+        pass
+
+    @abstractmethod
+    def _get_inputs():
+        """Update data."""
+        pass
+
+    def _error_ind(self, error_code) -> None:
+        LOGGER.error("ERROR: error_code=%s", error_code)
+        self._status = f"Error: {error_code}"
+
+    def _avail(self) -> None:
+        LOGGER.debug("AVAIL")
+        self.read_outputs()
+        self._set_outputs()
+
+    def _sync(self) -> None:
+        LOGGER.debug("SYNC")
+        self._get_inputs()
+        self.write_inputs()
+
+    def _status_ind(self, status: int) -> None:
+        LOGGER.info("STATUS: %s", status)
+        self._status = str(status)
+
+    def _profinet_signal_led_ind(self) -> None:
+        LOGGER.info("PROFINET LED SIGNAL")
+
+    def _poll_ind(self) -> None:
+        LOGGER.debug("POLL")
+
+        self.read_outputs()
+        self._set_outputs()
+
+        self._get_inputs()
+        self.write_inputs()
+
+        if self._update:
+            self._update(status=self._status)
+
+
+def get_sample_model() -> uphy_model.Root:
+    try:
+        with importlib.resources.as_file(importlib.resources.files(__name__)) as base:
+            if (path := base / "share" / "digio.json").exists():
+                return uphy_model.Root.parse_file(str(path))
+    except Exception as exception:
+        raise DeviceError(str(exception)) from exception
+    else:
+        raise DeviceError("Can't find sample model")
+
+def _get_handler(handler: Optional[str]):
+    if handler:
+        spec = importlib.util.spec_from_file_location("uphy.device.handler", handler)
+        device_handler_module = importlib.util.module_from_spec(spec)
+        sys.modules["uphy.device.handler"] = device_handler_module
+        spec.loader.exec_module(device_handler_module)
+    else:
+        from . import handler as device_handler_module
+
+    return device_handler_module.DeviceHandler
+
+
+def get_device_config(model: uphy_model.Root, protocol: Protocol):
+    root = model
+    device = api.Device.from_model(root, root.devices[0])
+    vars = api.SignalInfos.from_slots(device.slots)
+
+    if protocol == Protocol.ETHERCAT:
+        config = api.EthercatDevice(root, root.devices[0])
+    elif protocol == Protocol.PROFINET:
+        config = api.ProfinetConfig.from_model(root, root.devices[0])
+    elif protocol == Protocol.MODBUS:
+        config = api.ModbusDevice(root, root.devices[0])
+    else:
+        raise UnsupportedError(f"Unsupported protocol: {protocol}")
+
+    return device, config, vars
+
+
+def get_device_handler(
+    protocol: Protocol, model: uphy_model.Root = None, handler: Optional[str] = None
+) -> DeviceHandlerBase:
+    """Create a device handler from protocol and model information."""
+    device_handler = _get_handler(handler)
+    device, config, vars = get_device_config(model, protocol)
+    return device_handler(device=device, vars=vars, busconf=config)
+
+
+def init_transport_url(up: Up, transport: str):
+    url = URL(transport)
+    if url.scheme == "tcp":
+        up.tcp_transport_init(
+            url.host if url.host else "localhost", url.port if url.port else 5150
+        )
+    elif url.scheme == "":
+        up.serial_transport_init(transport)
+    else:
+        raise ApiError(f"Unknown transport {transport}")
+
+
+def run_client_blocking(up: Up, transport: str):
+    try:
+        LOGGER.info("Starting transport")
+        init_transport_url(up, transport)
+
+        up.rpc_init()
+
+        while True:
+            LOGGER.info("Starting application")
+
+            up.rpc_start()
+            up.init_device()
+
+            up.start_device()
+
+            up.write_inputs()
+
+            up.enable_watchdog(True)
+
+            while up.worker():
+                pass
+
+            LOGGER.info("Restarting application")
+    except ApiError as exception:
+        LOGGER.error(exception)
+    except GuiExit:
+        pass
+
+
+def run_client(
+    up: Up,
+    transport: str,
+):
+    # Run off main thread to make sure main thread can handle signals
+    runner = Thread(
+        target=partial(run_client_blocking, up, transport),
+        name="Device Runner",
+        daemon=True,
+    )
+    runner.start()
+    while runner.is_alive():
+        sleep(1)
+
+
+def run_client_and_server(up: Up, interface: str):
+    server = server_binary()
+
+    server_runner = subprocess.Popen([server, interface])
+    time.sleep(1)
+    try:
+        client_runner = Thread(
+            target=partial(run_client_blocking, up, "tcp://localhost"),
+            name="Device Runner",
+            daemon=True,
+        )
+        client_runner.start()
+
+        while client_runner.is_alive():
+            sleep(1)
+
+    finally:
+        server_runner.kill()
+        server_runner.wait()
+
+
+def run_server(interface: str):
+    server = server_binary()
+    subprocess.run([server, interface])

uphy_device-0.1.0.dev2794/uphy/device/__main__.py

@@ -0,0 +1,231 @@
+from contextlib import nullcontext
+import faulthandler
+import importlib.metadata
+from typing import Optional, Annotated
+
+import typer.rich_utils
+from uphy.device import gui
+from uphy.device import api
+import logging
+import typer
+from pathlib import Path
+from rich.logging import RichHandler
+from rich.table import Table
+from rich import print
+import importlib.metadata
+import importlib.util
+import importlib.resources
+import psutil
+import upgen.model.uphy as uphy_model
+
+from . import (
+    get_device_handler,
+    get_sample_model,
+    DeviceError,
+    run_client,
+    run_client_and_server,
+    run_server,
+    Protocol,
+    LOGGER,
+)
+
+from .server import mdns
+
+faulthandler.enable()
+
+app = typer.Typer(
+    pretty_exceptions_enable=False,
+    no_args_is_help=True,
+    name="device",
+    help="Run a U-Phy server from python.",
+)
+
+
+def _model_parser(path: Path) -> uphy_model.Root:
+    try:
+        return uphy_model.Root.parse_file(str(path))
+    except Exception as exception:
+        raise typer.BadParameter(str(exception)) from exception
+
+
+def _interface_parser(interface: str) -> str:
+    interfaces = psutil.net_if_addrs()
+    if interface not in interfaces:
+        raise typer.BadParameter(
+            f"Interface '{interface}' not found in {list(interfaces)}"
+        )
+    return interface
+
+
+INTERFACE_HELP = "The network interface to run the server on. NOTE: This should not be your main network card, but a secondary card used for protocol data."
+INTERFACE_OPTION = typer.Option(
+    help=INTERFACE_HELP,
+    parser=_interface_parser,
+    prompt="Enter network interface to use",
+)
+TRANSPORT_HELP = "The target transport to connect to the running server. 'tcp://' for network localhost access, '/dev/uphyX' or 'COMX') for serial connection to device."
+MODEL_HELP = "Path to a U-Phy device model json file."
+MODEL_OPTION = typer.Option(help=MODEL_HELP, parser=_model_parser)
+HANDLER_HELP = "Path to custom device handler python script. A template file can be generated using 'uphy-device export-handler'."
+MDNS_HELP = "Expose device and model for discovery over mdns/zeroconf, useful to use with a supported controller."
+
+
+def _set_logging(level, force=False):
+    logging.basicConfig(
+        level=level,
+        format="%(message)s",
+        datefmt="[%X]",
+        handlers=[RichHandler(markup=True)],
+        force=force,
+    )
+
+
+_set_logging(level=logging.INFO)
+
+
+@app.command(no_args_is_help=True)
+def client(
+    protocol: Protocol,
+    transport: Annotated[
+        str,
+        typer.Option(help=TRANSPORT_HELP),
+    ],
+    model: Annotated[Optional[uphy_model.Root], MODEL_OPTION] = None,
+    verbose: bool = False,
+    handler: Annotated[Optional[str], typer.Option(help=HANDLER_HELP)] = None,
+    gui_arg: Annotated[gui.Gui, typer.Option("--gui")] = gui.Gui.dear,
+):
+    """Run a model from source XML file"""
+
+    try:
+        if verbose:
+            _set_logging(level=logging.DEBUG, force=True)
+
+        if model is None:
+            model = get_sample_model()
+
+        up = get_device_handler(protocol, model, handler)
+        with up.gui(gui_arg):
+            run_client(up, transport)
+
+    except (DeviceError, api.ApiError) as exception:
+        LOGGER.error(str(exception))
+        LOGGER.debug("", exc_info=True)
+    except gui.GuiExit:
+        pass
+
+
+@app.command()
+def mono(
+    protocol: Protocol,
+    interface: Annotated[
+        str,
+        INTERFACE_OPTION,
+    ],
+    model: Annotated[Optional[uphy_model.Root], MODEL_OPTION] = None,
+    verbose: bool = False,
+    handler: Annotated[Optional[str], typer.Option(help=HANDLER_HELP)] = None,
+    gui_arg: Annotated[gui.Gui, typer.Option("--gui")] = gui.Gui.dear,
+    run_mdns: Annotated[bool, typer.Option("--mdns", help=MDNS_HELP)] = False,
+):
+    """Run a client and server on same system."""
+    try:
+        if verbose:
+            _set_logging(level=logging.DEBUG, force=True)
+
+        if model is None:
+            model = get_sample_model()
+
+        if run_mdns:
+            mdns_ctx = mdns.run(
+                model=model,
+                device=model.devices[0],
+                interface=interface,
+                protocol=protocol,
+            )
+        else:
+            mdns_ctx = nullcontext()
+
+        with mdns_ctx:
+            up = get_device_handler(protocol, model, handler)
+            with up.gui(gui_arg):
+                run_client_and_server(up, interface)
+
+    except (DeviceError, api.ApiError) as exception:
+        LOGGER.error(str(exception))
+        LOGGER.debug("", exc_info=True)
+    except gui.GuiExit:
+        pass
+
+
+@app.command()
+def build():
+    """Start building your device model"""
+
+    print("To start building your device you need to create a model of your device describing its inputs and outputs.")
+    print("This is done using RT-Labs device builder at https://devicebuilder.rt-labs.com/")
+    print()
+    print("After you have configured your model, download the model file into a known location")
+    print()
+    print()
+    if typer.confirm(
+        "Start a web browser navigating to this location?"
+    ):
+        typer.launch("https://devicebuilder.rt-labs.com/")
+
+
+@app.command()
+def export_handler(file: Annotated[typer.FileBinaryWrite, typer.Argument(mode="xb")]):
+    """Export a template handler to file"""
+    with importlib.resources.open_binary(__package__, "handler.py") as template:
+        file.write(template.read())
+
+
+@app.command()
+def server(
+    interface: Annotated[
+        str,
+        INTERFACE_OPTION,
+    ],
+):
+    """Start a u-phy server on your local system. This will listen to connections from client instances to run the u-phy system."""
+    try:
+        run_server(interface)
+    except (DeviceError, api.ApiError) as exception:
+        LOGGER.error(str(exception))
+        LOGGER.debug("", exc_info=True)
+
+
+@app.command()
+def discover():
+    """Tries to discovery locally attached u-phy servers"""
+    import serial.tools.list_ports
+
+    table = Table("ID", "Serial Number", "Subsystem", title="Serial ports")
+    for port in serial.tools.list_ports.comports():
+        print(port.usb_info())
+        if port.vid != 0x04D8 or port.pid != 0x1301:
+            continue
+        index = port.location.split(".")[-1]
+        if index == "0":
+            system = "server"
+        elif index == "2":
+            system = "console"
+        else:
+            system = "unkown"
+        table.add_row(port.name, port.serial_number, system)
+
+    print(table)
+
+
+@app.command()
+def readme():
+    print("The main documentation site for U-Phy is located at https://docs.rt-labs.com/u-phy.")
+    if typer.confirm(
+        "Start a web browser navigating to site?"
+    ):
+        typer.launch("https://docs.rt-labs.com/u-phy")
+
+
+if __name__ == "__main__":
+    app()