uphy-controller 1.0.2__tar.gz → 1.1.0__tar.gz

{uphy_controller-1.0.2 → uphy_controller-1.1.0}/LICENSE.txt

@@ -1,5 +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.
+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-1.0.2/src/uphy_controller.egg-info → uphy_controller-1.1.0}/PKG-INFO

@@ -1,47 +1,47 @@
-Metadata-Version: 2.4
-Name: uphy-controller
-Version: 1.0.2
-Summary: U-Phy Controller
-License-Expression: LicenseRef-RT-Labs-Commercial-Agreement
-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.9.0,>=3.8.3
-Requires-Dist: requests>=2.32.3
-Requires-Dist: rich>=13.9.2
-Requires-Dist: typer>=0.12.5
-Requires-Dist: uphy
-Requires-Dist: zeroconf>=0.135.0
-Dynamic: license-file
-
-# U-Phy Controller
-
-This contain a python based U-Phy device controller that act as a fieldbus master/controller.
-
-Supported fieldbuses:
-
-- modbus
-
-## Install
-
-```sh
-uv pip install uphy-controller
-```
-
-## Workflow
-
-```sh
-# Start up controller against an existing device
-uphy-controller modbus --model [PATH_TO_MODEL] --target [UUID]:[HOST]:[PORT]
-```
-
-
-```sh
-# Start up controller against discovered devices that expose their model via
-# mdns.
-uphy-controller mdns
-```
+Metadata-Version: 2.4
+Name: uphy-controller
+Version: 1.1.0
+Summary: U-Phy Controller
+License-Expression: LicenseRef-RT-Labs-Commercial-Agreement
+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.9.0,>=3.8.3
+Requires-Dist: requests>=2.32.3
+Requires-Dist: rich>=13.9.2
+Requires-Dist: typer>=0.12.5
+Requires-Dist: uphy
+Requires-Dist: zeroconf>=0.135.0
+Dynamic: license-file
+
+# U-Phy Controller
+
+This contain a python based U-Phy device controller that act as a fieldbus master/controller.
+
+Supported fieldbuses:
+
+- modbus
+
+## Install
+
+```sh
+uv pip install uphy-controller
+```
+
+## Workflow
+
+```sh
+# Start up controller against an existing device
+uphy-controller modbus --model [PATH_TO_MODEL] --target [UUID]:[HOST]:[PORT]
+```
+
+
+```sh
+# Start up controller against discovered devices that expose their model via
+# mdns.
+uphy-controller mdns
+```

{uphy_controller-1.0.2 → uphy_controller-1.1.0}/README.md

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

{uphy_controller-1.0.2 → uphy_controller-1.1.0}/pyproject.toml

@@ -1,33 +1,33 @@
-[project]
-name = "uphy-controller"
-version = "1.0.2"
-description = "U-Phy Controller"
-readme = "README.md"
-requires-python = ">=3.10"
-dependencies = [
-    "dearpygui>=2.0.0",
-    "pymodbus (>=3.8.3,<3.9.0)",
-    "requests>=2.32.3",
-    "rich>=13.9.2",
-    "typer>=0.12.5",
-    "uphy",
-    "zeroconf>=0.135.0",
-]
-license = "LicenseRef-RT-Labs-Commercial-Agreement"
-license-files = [
-    "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'
-
-[tool.uv.sources]
-uphy = { workspace = true }
+[project]
+name = "uphy-controller"
+version = "1.1.0"
+description = "U-Phy Controller"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "dearpygui>=2.0.0",
+    "pymodbus (>=3.8.3,<3.9.0)",
+    "requests>=2.32.3",
+    "rich>=13.9.2",
+    "typer>=0.12.5",
+    "uphy",
+    "zeroconf>=0.135.0",
+]
+license = "LicenseRef-RT-Labs-Commercial-Agreement"
+license-files = [
+    "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'
+
+[tool.uv.sources]
+uphy = { workspace = true }

{uphy_controller-1.0.2 → uphy_controller-1.1.0}/setup.cfg

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

{uphy_controller-1.0.2 → uphy_controller-1.1.0}/src/uphy/__init__.py

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

{uphy_controller-1.0.2 → uphy_controller-1.1.0}/src/uphy/controller/__init__.py

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

{uphy_controller-1.0.2 → uphy_controller-1.1.0}/src/uphy/controller/__main__.py

@@ -1,190 +1,190 @@
-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.runtime import Root as RootModel
-from uphy.cli import VERBOSE_OPTION, configure_logging
-
-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",
-)
-
-configure_logging(level=logging.INFO)
-
-@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(name="modbus")
-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,
-    verbose: Annotated[bool, VERBOSE_OPTION] = False,
-):
-    """Run controller against a set of fixed uphy devices."""
-    models = [RootModel.parse_file(file) for file in model]
-
-    devices_by_id = {
-        str(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 id, (_, device) in devices_by_id.items():
-            table.add_row(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)
-                    continue
-
-            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(
-    verbose: Annotated[bool, VERBOSE_OPTION] = False,
-):
-    """Run controller against devices automatically discovered via 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):
-        properties = info.decoded_properties
-        model_port = properties.get("model-port")
-        model_path = properties.get("model-path")
-        if not model_port or not model_path:
-            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(address, info.port)
-                try:
-                    response = requests.get(model_url)
-                    response.raise_for_status()
-                    model_raw = response.content
-                    break
-                except Exception as exception:
-                    LOG.warning("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)
-            device = model.device
-
-            LOG.info("Adding device %s", device.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()
+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.runtime import Root as RootModel
+from uphy.cli import VERBOSE_OPTION, configure_logging
+
+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",
+)
+
+configure_logging(level=logging.INFO)
+
+@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(name="modbus")
+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,
+    verbose: Annotated[bool, VERBOSE_OPTION] = False,
+):
+    """Run controller against a set of fixed uphy devices."""
+    models = [RootModel.parse_file(file) for file in model]
+
+    devices_by_id = {
+        str(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 id, (_, device) in devices_by_id.items():
+            table.add_row(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)
+                    continue
+
+            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(
+    verbose: Annotated[bool, VERBOSE_OPTION] = False,
+):
+    """Run controller against devices automatically discovered via 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):
+        properties = info.decoded_properties
+        model_port = properties.get("model-port")
+        model_path = properties.get("model-path")
+        if not model_port or not model_path:
+            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(address, info.port)
+                try:
+                    response = requests.get(model_url)
+                    response.raise_for_status()
+                    model_raw = response.content
+                    break
+                except Exception as exception:
+                    LOG.warning("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)
+            device = model.device
+
+            LOG.info("Adding device %s", device.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-1.0.2 → uphy_controller-1.1.0}/src/uphy/controller/gui.py

@@ -1,175 +1,175 @@
-import math
-from dataclasses import dataclass
-
-import dearpygui.dearpygui as dpg
-from upgen.model.uphy import DataType
-from upgen.model.runtime import Root as RootModel, Device, Slot, Signal, Parameter
-
-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**31 - 1), # Incorrect max but larger values do not work with dpg
-    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]
-        widget = dpg.add_input_float if signal.datatype == DataType.REAL32 else dpg.add_input_int
-        with dpg.group():
-            self.value_id = [
-                widget(
-                    width=100,
-                    callback=lambda sender, app_data, user_data: self.callback(
-                        ix, app_data
-                    ),
-                    min_value=min,
-                    max_value=max,
-                    min_clamped=True,
-                    max_clamped=True,
-                )
-                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 = [
-        window
-        for window in dpg.get_windows()
-        if dpg.get_item_user_data(window) == "device"
-    ]
-    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}",
-        user_data="device"
-    ) 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):
-    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 slot.inputs:
-            with dpg.table_row():
-                inputs[signal.name] = InputGUI(signal)
-
-        outputs: dict[str, OutputGUI] = {}
-        for signal in slot.outputs:
-            with dpg.table_row():
-                outputs[signal.name] = OutputGUI(signal)
-
-        params: dict[str, ParamGUI] = {}
-        for signal in slot.parameters:
-            with dpg.table_row():
-                params[signal.name] = ParamGUI(signal)
-
-    return SlotGUI(inputs=inputs, outputs=outputs, params=params)
-
-
-def setup():
-    dpg.create_context()
-    def on_key_q(s, a, u):
-        if dpg.is_key_down(dpg.mvKey_LControl):
-            dpg.stop_dearpygui()
-
-    def on_key_esc(s, a, u):
-        dpg.stop_dearpygui()
-
-    with dpg.handler_registry():
-        dpg.add_key_press_handler(key=dpg.mvKey_Q, callback=on_key_q)
-        dpg.add_key_press_handler(key=dpg.mvKey_Escape, callback=on_key_esc)
-
-    dpg.create_viewport(title="U-Phy Controller", width=800)
-    dpg.setup_dearpygui()
-
-
-def run():
-    dpg.show_viewport()
-    dpg.start_dearpygui()
-    dpg.destroy_context()
+import math
+from dataclasses import dataclass
+
+import dearpygui.dearpygui as dpg
+from upgen.model.uphy import DataType
+from upgen.model.runtime import Root as RootModel, Device, Slot, Signal, Parameter
+
+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**31 - 1), # Incorrect max but larger values do not work with dpg
+    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]
+        widget = dpg.add_input_float if signal.datatype == DataType.REAL32 else dpg.add_input_int
+        with dpg.group():
+            self.value_id = [
+                widget(
+                    width=100,
+                    callback=lambda sender, app_data, user_data: self.callback(
+                        ix, app_data
+                    ),
+                    min_value=min,
+                    max_value=max,
+                    min_clamped=True,
+                    max_clamped=True,
+                )
+                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 = [
+        window
+        for window in dpg.get_windows()
+        if dpg.get_item_user_data(window) == "device"
+    ]
+    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}",
+        user_data="device"
+    ) 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):
+    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 slot.inputs:
+            with dpg.table_row():
+                inputs[signal.name] = InputGUI(signal)
+
+        outputs: dict[str, OutputGUI] = {}
+        for signal in slot.outputs:
+            with dpg.table_row():
+                outputs[signal.name] = OutputGUI(signal)
+
+        params: dict[str, ParamGUI] = {}
+        for signal in slot.parameters:
+            with dpg.table_row():
+                params[signal.name] = ParamGUI(signal)
+
+    return SlotGUI(inputs=inputs, outputs=outputs, params=params)
+
+
+def setup():
+    dpg.create_context()
+    def on_key_q(s, a, u):
+        if dpg.is_key_down(dpg.mvKey_LControl):
+            dpg.stop_dearpygui()
+
+    def on_key_esc(s, a, u):
+        dpg.stop_dearpygui()
+
+    with dpg.handler_registry():
+        dpg.add_key_press_handler(key=dpg.mvKey_Q, callback=on_key_q)
+        dpg.add_key_press_handler(key=dpg.mvKey_Escape, callback=on_key_esc)
+
+    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-1.0.2 → uphy_controller-1.1.0}/src/uphy/controller/modbus.py

@@ -1,108 +1,108 @@
-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
-import struct
-
-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=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(output.signal)
-                    index = base
-                    base += count
-
-                    if output.value is None:
-                        continue
-
-                    try:
-                        payload = []
-                        for value in output.value:
-                            payload.extend(client.convert_to_registers(value, data_type))
-                    except struct.error:
-                        logging.error("Bad payload")
-                        continue
-
-                    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)
+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
+import struct
+
+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=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(output.signal)
+                    index = base
+                    base += count
+
+                    if output.value is None:
+                        continue
+
+                    try:
+                        payload = []
+                        for value in output.value:
+                            payload.extend(client.convert_to_registers(value, data_type))
+                    except struct.error:
+                        logging.error("Bad payload")
+                        continue
+
+                    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-1.0.2 → uphy_controller-1.1.0/src/uphy_controller.egg-info}/PKG-INFO

@@ -1,47 +1,47 @@
-Metadata-Version: 2.4
-Name: uphy-controller
-Version: 1.0.2
-Summary: U-Phy Controller
-License-Expression: LicenseRef-RT-Labs-Commercial-Agreement
-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.9.0,>=3.8.3
-Requires-Dist: requests>=2.32.3
-Requires-Dist: rich>=13.9.2
-Requires-Dist: typer>=0.12.5
-Requires-Dist: uphy
-Requires-Dist: zeroconf>=0.135.0
-Dynamic: license-file
-
-# U-Phy Controller
-
-This contain a python based U-Phy device controller that act as a fieldbus master/controller.
-
-Supported fieldbuses:
-
-- modbus
-
-## Install
-
-```sh
-uv pip install uphy-controller
-```
-
-## Workflow
-
-```sh
-# Start up controller against an existing device
-uphy-controller modbus --model [PATH_TO_MODEL] --target [UUID]:[HOST]:[PORT]
-```
-
-
-```sh
-# Start up controller against discovered devices that expose their model via
-# mdns.
-uphy-controller mdns
-```
+Metadata-Version: 2.4
+Name: uphy-controller
+Version: 1.1.0
+Summary: U-Phy Controller
+License-Expression: LicenseRef-RT-Labs-Commercial-Agreement
+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.9.0,>=3.8.3
+Requires-Dist: requests>=2.32.3
+Requires-Dist: rich>=13.9.2
+Requires-Dist: typer>=0.12.5
+Requires-Dist: uphy
+Requires-Dist: zeroconf>=0.135.0
+Dynamic: license-file
+
+# U-Phy Controller
+
+This contain a python based U-Phy device controller that act as a fieldbus master/controller.
+
+Supported fieldbuses:
+
+- modbus
+
+## Install
+
+```sh
+uv pip install uphy-controller
+```
+
+## Workflow
+
+```sh
+# Start up controller against an existing device
+uphy-controller modbus --model [PATH_TO_MODEL] --target [UUID]:[HOST]:[PORT]
+```
+
+
+```sh
+# Start up controller against discovered devices that expose their model via
+# mdns.
+uphy-controller mdns
+```