uphy-controller 0.1.0.dev2794__tar.gz

uphy_controller-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_controller-0.1.0.dev2794/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.1
+Name: uphy-controller
+Version: 0.1.0.dev2794
+Summary: Add your description here
+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: dearpygui>=2.0.0
+Requires-Dist: pymodbus>=3.7.3
+Requires-Dist: rich>=13.9.2
+Requires-Dist: typer>=0.12.5
+Requires-Dist: zeroconf>=0.135.0
+
+# U-Phy Controller
+
+This contain a python based U-Phy device controller that act as a fieldbus master/controller.
+
+Supported fieldbuses:
+
+- modbus-tcp
+
+## Install
+
+```sh
+uv pip install uphy-controller
+```
+
+## Workflow
+
+```sh
+# Start up controller against an existing device
+uphy-controller modbus-tcp --model [PATH_TO_MODEL] --target [UUID]:[HOST]:[PORT]
+```

uphy_controller-0.1.0.dev2794/README.md

@@ -0,0 +1,20 @@
+# U-Phy Controller
+
+This contain a python based U-Phy device controller that act as a fieldbus master/controller.
+
+Supported fieldbuses:
+
+- modbus-tcp
+
+## Install
+
+```sh
+uv pip install uphy-controller
+```
+
+## Workflow
+
+```sh
+# Start up controller against an existing device
+uphy-controller modbus-tcp --model [PATH_TO_MODEL] --target [UUID]:[HOST]:[PORT]
+```

uphy_controller-0.1.0.dev2794/pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+name = "uphy-controller"
+version = "0.1.0.dev2794"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "dearpygui>=2.0.0",
+    "pymodbus>=3.7.3",
+    "rich>=13.9.2",
+    "typer>=0.12.5",
+    "zeroconf>=0.135.0",
+]
+license = {file = "LICENSE.txt"}
+
+
+[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-controller = "uphy.controller.__main__:app"
+
+[project.entry-points.'uphy.cli']
+controller = 'uphy.controller.__main__:app'

uphy_controller-0.1.0.dev2794/setup.cfg

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

uphy_controller-0.1.0.dev2794/src/uphy/__init__.py

@@ -0,0 +1,2 @@
+# This is a namespace package to hold on to uphy namespace
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)

uphy_controller-0.1.0.dev2794/src/uphy/controller/__init__.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Target:
+    id: str
+    host: str
+    port: str = 502

uphy_controller-0.1.0.dev2794/src/uphy/controller/__main__.py

@@ -0,0 +1,187 @@
+import logging
+from functools import partial
+from pathlib import Path
+from threading import Event, Thread
+from typing import Annotated
+from rich.table import Table
+from rich import print
+
+from typer import Option, Typer, BadParameter
+from upgen.model.uphy import Root as RootModel
+
+from . import Target, gui, modbus
+
+LOG = logging.getLogger(__name__)
+
+app = Typer(
+    pretty_exceptions_enable=False,
+    no_args_is_help=True,
+    name="controller",
+    help="Run a demo modbus controller based on a model",
+)
+
+
+@staticmethod
+def parse_target(value: str):
+    values = value.split(":")
+    if len(values) != 3:
+        raise BadParameter(f"Expected uuid:host:port, got {value}")
+
+    return Target(*value.split(":"))
+
+
+@app.command()
+def modbus_tcp(
+    model: Annotated[list[Path], Option()],
+    target: Annotated[
+        list[Target] | None,
+        Option(
+            parser=parse_target,
+            metavar="ID:HOST:PORT",
+            help="Targets to connect controller to, where ID is a device uuid or name, HOST is hostname to connect to and PORT is the port the modbus-tcp server is listening on.",
+        ),
+    ] = None,
+):
+    models = [RootModel.parse_file(file) for file in model]
+
+    devices_by_id = {
+        device.id: (root, device) for root in models for device in root.devices
+    }
+
+    devices_by_name = {
+        device.name: (root, device) for root in models for device in root.devices
+    }
+
+    if target is None:
+        table = Table(title="Available devices")
+        table.add_column("ID")
+        table.add_column("Name")
+
+        for _, device in devices_by_id.values():
+            table.add_row(str(device.id), device.name)
+
+        print(table)
+        print()
+        print(
+            "Please add targets to connect to using the --target ID:HOST:PORT argument."
+        )
+        print()
+        exit(-1)
+
+    gui.setup()
+
+    stop = Event()
+    try:
+        for target_obj in target:
+            root, device = devices_by_id.get(target_obj.id, (None, None))
+            if not device:
+                root, device = devices_by_name.get(target_obj.id, (None, None))
+                if not device:
+                    LOG.warning("Unable to find device %s", target_obj.id)
+
+            device_gui = gui.add_device(
+                root, device, f"{target_obj.host}:{target_obj.port}"
+            )
+
+            thread = Thread(
+                target=partial(modbus.target_runner, stop, target_obj, device_gui),
+                name=device.name,
+            )
+            thread.start()
+
+        gui.run()
+    finally:
+        stop.set()
+
+
+@app.command()
+def mdns():
+    from zeroconf import (
+        Zeroconf,
+        ServiceBrowser,
+        ServiceStateChange,
+        IPVersion,
+        ServiceInfo,
+    )
+    import requests
+
+    zeroconf = Zeroconf(ip_version=IPVersion.V4Only)
+    services = ["_modbus._tcp.local."]
+
+    device_runners: dict[tuple, Event] = {}
+
+    def on_device_added(device_key: tuple, info: ServiceInfo):
+        addresses = info.parsed_addresses()
+        properties = info.decoded_properties
+        model_port = properties.get("model-port")
+        model_path = properties.get("model-path")
+        device_id = properties.get("device-id")
+        if not model_port or not model_path or not device_id:
+            LOG.error("Missing model info for %s", info.name)
+            return
+
+        device_stop = Event()
+        device_runners[device_key] = device_stop
+
+        def _run():
+            for address in info.parsed_addresses(IPVersion.V4Only):
+                model_url = f"http://{address}:{model_port}{model_path}"
+                target_obj = Target(device_id, address, info.port)
+                try:
+                    model_raw = requests.get(model_url).content
+                    break
+                except Exception as exception:
+                    LOG.debug("Failed to connect to %s:%r", model_url, exception)
+                    continue
+            else:
+                LOG.error("Unable to get model for %s", info.name)
+                return
+
+
+            model = RootModel.parse_raw(model_raw)
+            for device in model.devices:
+                if str(device.id) == device_id:
+                    break
+            else:
+                LOG.error("Can't find device %s in model", device_id)
+                return
+
+            LOG.info("Adding device %s", info.name)
+            device_gui = gui.add_device(model, device, address)
+            modbus.target_runner(device_stop, target_obj, device_gui)
+            device_gui.close()
+
+        thread = Thread(
+            target=_run,
+        )
+        thread.start()
+
+    def on_service_state_change(
+        zeroconf: Zeroconf,
+        service_type: str,
+        name: str,
+        state_change: ServiceStateChange,
+    ) -> None:
+        print(f"Service {name}: {state_change}")
+
+        device_key = (service_type, name)
+
+        if state_change is ServiceStateChange.Added:
+            info = zeroconf.get_service_info(service_type, name)
+            if info and info.port:
+                on_device_added(device_key, info)
+
+        if state_change is ServiceStateChange.Removed:
+            device_stop = device_runners.pop(device_key, None)
+            if device_stop:
+                device_stop.set()
+
+    gui.setup()
+
+    ServiceBrowser(zeroconf, services, handlers=[on_service_state_change])
+
+    gui.run()
+
+
+if __name__ == "__main__":
+    app()

uphy_controller-0.1.0.dev2794/src/uphy/controller/gui.py

@@ -0,0 +1,157 @@
+import math
+from dataclasses import dataclass
+
+import dearpygui.dearpygui as dpg
+from upgen.model.uphy import DataType, Device, Signal, Slot, Parameter
+from upgen.model.uphy import Root as RootModel
+
+datatype_to_min_max = {
+    DataType.INT8: (-(2**7), 2**7 - 1),
+    DataType.INT16: (-(2**15), 2**15 - 1),
+    DataType.INT32: (-(2**31), 2**31 - 1),
+    DataType.UINT8: (0, 2**8 - 1),
+    DataType.UINT16: (0, 2**16 - 1),
+    DataType.UINT32: (0, 2**32 - 1),
+    DataType.REAL32: (-math.inf, math.inf),
+}
+
+
+@dataclass
+class InputGUI:
+    signal: Signal
+    value_id: list[str | int]
+
+    def __init__(self, signal: Signal):
+        self.signal = signal
+        dpg.add_text(signal.name)
+        with dpg.group():
+            self.value_id = [
+                dpg.add_text("N/A") for _ in range(signal.array_length or 1)
+            ]
+
+    def update(self, value: list[int | float] | None):
+        if value is None:
+            for ix in range(self.signal.array_length or 1):
+                dpg.set_value(self.value_id[ix], "N/A")
+        else:
+            for ix in range(self.signal.array_length or 1):
+                dpg.set_value(self.value_id[ix], value[ix])
+
+
+@dataclass
+class OutputGUI:
+    signal: Signal
+    value_id: list[str | int]
+    value: list[int] | None = None
+
+    def __init__(self, signal: Signal):
+        self.signal = signal
+        self.value = [0] * (signal.array_length or 1)
+        dpg.add_text(signal.name)
+        min, max = datatype_to_min_max[signal.datatype]
+        with dpg.group():
+            self.value_id = [
+                dpg.add_input_int(
+                    width=100,
+                    callback=lambda sender, app_data, user_data: self.callback(
+                        ix, app_data
+                    ),
+                    min_value=min,
+                    max_value=max,
+                )
+                for ix in range(signal.array_length or 1)
+            ]
+
+    def callback(self, ix: int, value: int):
+        self.value[ix] = value
+
+
+class ParamGUI:
+    def __init__(self, signal: Parameter):
+        self.signal = signal
+
+
+@dataclass
+class SlotGUI:
+    inputs: dict[str, InputGUI]
+    outputs: dict[str, OutputGUI]
+    params: dict[str, ParamGUI]
+
+
+@dataclass
+class DeviceGUI:
+    widget: int | str
+    slots: dict[str, SlotGUI]
+    status_id: str | int
+
+    def update_status(self, status: str):
+        dpg.set_value(self.status_id, status)
+
+    def close(self):
+        dpg.delete_item(self.widget)
+
+
+def add_device(model: RootModel, device: Device, suffix: str) -> DeviceGUI:
+    width = 300
+    windows = dpg.get_windows()
+    for ix, window in enumerate(windows):
+        dpg.set_item_pos(window, [ix * width, 0])
+    ix = len(windows)
+
+    with dpg.window(
+        width=width,
+        pos=[ix * width, 0],
+        autosize=True,
+        label=f"{device.name} - {suffix}",
+    ) as window:
+        with dpg.group(horizontal=True):
+            dpg.add_text("Status")
+            status_id = dpg.add_text()
+
+        slot_guis = {}
+        for slot in device.slots:
+            with dpg.child_window(auto_resize_y=True):
+                slot_gui = _add_slot(model, slot)
+                slot_guis[slot.name] = slot_gui
+
+    return DeviceGUI(window, slot_guis, status_id)
+
+
+def _add_slot(model: RootModel, slot: Slot):
+    module = model.get_module(slot.module)
+    dpg.add_text(f"{slot.name}")
+
+    dpg.add_separator()
+
+    with dpg.group(indent=10), dpg.table(label=slot.name, header_row=False):
+        dpg.add_table_column()
+        dpg.add_table_column()
+
+        inputs: dict[str, InputGUI] = {}
+        for signal in module.inputs:
+            with dpg.table_row():
+                inputs[signal.id] = InputGUI(signal)
+
+        outputs: dict[str, OutputGUI] = {}
+        for signal in module.outputs:
+            with dpg.table_row():
+                outputs[signal.id] = OutputGUI(signal)
+
+        params: dict[str, ParamGUI] = {}
+        for signal in module.parameters:
+            with dpg.table_row():
+                params[signal.id] = ParamGUI(signal)
+
+    return SlotGUI(inputs=inputs, outputs=outputs, params=params)
+
+
+def setup():
+    dpg.create_context()
+    dpg.create_viewport(title="U-Phy Controller", width=800)
+    dpg.setup_dearpygui()
+
+
+def run():
+    dpg.show_viewport()
+    dpg.start_dearpygui()
+    dpg.destroy_context()

uphy_controller-0.1.0.dev2794/src/uphy/controller/modbus.py

@@ -0,0 +1,103 @@
+import logging
+from threading import Event
+from time import sleep
+
+import pymodbus.client
+from pymodbus.client import ModbusBaseClient, ModbusTcpClient
+import pymodbus.exceptions
+from upgen.model.uphy import DataType, Signal
+
+from . import Target, gui
+
+datatype_to_modbus_type = {
+    DataType.INT8: ModbusBaseClient.DATATYPE.INT16,
+    DataType.INT16: ModbusBaseClient.DATATYPE.INT16,
+    DataType.INT32: ModbusBaseClient.DATATYPE.INT32,
+    DataType.UINT8: ModbusBaseClient.DATATYPE.UINT16,
+    DataType.UINT16: ModbusBaseClient.DATATYPE.UINT16,
+    DataType.UINT32: ModbusBaseClient.DATATYPE.UINT32,
+    DataType.REAL32: ModbusBaseClient.DATATYPE.FLOAT32,
+}
+
+
+def get_type(datatype: DataType) -> tuple[ModbusBaseClient.DATATYPE, int]:
+    data_type = datatype_to_modbus_type[datatype]
+    data_type_bits = data_type.value[1] * 16
+    return data_type, data_type_bits
+
+
+def signal_to_regs_and_type(signal: Signal):
+    data_type, data_bits = get_type(signal.datatype)
+    data_regs = bits_to_regs(data_bits) * (signal.array_length or 1)
+    return data_regs, data_type
+
+
+def bits_to_regs(bits: int) -> None:
+    return (bits + 15) // 16
+
+
+def target_runner(stop: Event, target: Target, device_gui: gui.DeviceGUI):
+    device_gui.update_status("CONNECTING")
+    client = ModbusTcpClient(target.host, port=target.port)
+
+    while not stop.is_set():
+        try:
+            client.connect()
+
+            base = 0
+            for slot in device_gui.slots.values():
+                for input in slot.inputs.values():
+                    count, data_type = signal_to_regs_and_type(input.signal)
+                    index = base
+                    base += count
+                    try:
+                        response = client.read_holding_registers(index, count)
+                        if response.isError():
+                            raise pymodbus.ModbusException("Error")
+                    except pymodbus.exceptions.ConnectionException:
+                        raise
+                    except pymodbus.ModbusException as exception:
+                        logging.error("Error on read %d - %r", index, exception)
+                        input.update(None)
+                        continue
+
+                    values = [
+                        client.convert_from_registers(
+                            response.registers[ix : ix + data_type.value[1]], data_type
+                        )
+                        for ix in range(0, count, data_type.value[1])
+                    ]
+                    input.update(values)
+
+                for output in slot.outputs.values():
+                    count, data_type = signal_to_regs_and_type(input.signal)
+                    index = base
+                    base += count
+
+                    if output.value is None:
+                        continue
+
+                    payload = []
+                    for value in output.value:
+                        payload.extend(client.convert_to_registers(value, data_type))
+
+                    try:
+                        response = client.write_registers(index, payload)
+                        if response.isError():
+                            raise pymodbus.ModbusException("Error")
+                    except pymodbus.exceptions.ConnectionException:
+                        raise
+                    except pymodbus.ModbusException as exception:
+                        logging.error("Error on read %d - %r", index, exception)
+
+                for param in slot.params.values():
+                    count = bits_to_regs(param.signal.bitlen)
+                    index = base
+                    base += count
+        except pymodbus.ModbusException as exception:
+            device_gui.update_status("ERROR")
+            logging.error("%r", exception)
+            sleep(2)
+        else:
+            device_gui.update_status("CONNECTED")
+            sleep(0.5)

uphy_controller-0.1.0.dev2794/src/uphy_controller.egg-info/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.1
+Name: uphy-controller
+Version: 0.1.0.dev2794
+Summary: Add your description here
+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: dearpygui>=2.0.0
+Requires-Dist: pymodbus>=3.7.3
+Requires-Dist: rich>=13.9.2
+Requires-Dist: typer>=0.12.5
+Requires-Dist: zeroconf>=0.135.0
+
+# U-Phy Controller
+
+This contain a python based U-Phy device controller that act as a fieldbus master/controller.
+
+Supported fieldbuses:
+
+- modbus-tcp
+
+## Install
+
+```sh
+uv pip install uphy-controller
+```
+
+## Workflow
+
+```sh
+# Start up controller against an existing device
+uphy-controller modbus-tcp --model [PATH_TO_MODEL] --target [UUID]:[HOST]:[PORT]
+```

uphy_controller-0.1.0.dev2794/src/uphy_controller.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE.txt
+README.md
+pyproject.toml
+src/uphy/__init__.py
+src/uphy/controller/__init__.py
+src/uphy/controller/__main__.py
+src/uphy/controller/gui.py
+src/uphy/controller/modbus.py
+src/uphy_controller.egg-info/PKG-INFO
+src/uphy_controller.egg-info/SOURCES.txt
+src/uphy_controller.egg-info/dependency_links.txt
+src/uphy_controller.egg-info/entry_points.txt
+src/uphy_controller.egg-info/requires.txt
+src/uphy_controller.egg-info/top_level.txt

uphy_controller-0.1.0.dev2794/src/uphy_controller.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

uphy_controller-0.1.0.dev2794/src/uphy_controller.egg-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+uphy-controller = uphy.controller.__main__:app
+
+[uphy.cli]
+controller = uphy.controller.__main__:app

uphy_controller-0.1.0.dev2794/src/uphy_controller.egg-info/requires.txt

@@ -0,0 +1,5 @@
+dearpygui>=2.0.0
+pymodbus>=3.7.3
+rich>=13.9.2
+typer>=0.12.5
+zeroconf>=0.135.0

uphy_controller-0.1.0.dev2794/src/uphy_controller.egg-info/top_level.txt

@@ -0,0 +1 @@
+uphy