Release Candidate 1

.vscode/extensions.json

@@ -0,0 +1,10 @@
+{
+	// See http://go.microsoft.com/fwlink/?LinkId=827846
+	// for the documentation about the extensions.json format
+	"recommendations": [
+		"ms-vscode.cpptools",
+		"ms-python.python",
+		"ms-python.vscode-pylance",
+		"bungcip.better-toml"
+	],
+}

.vscode/launch.json

@@ -0,0 +1,16 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python: Attach",
+            "type": "python",
+            "request": "attach",
+            "port": 3000,
+            "host": "127.0.0.1",
+            "justMyCode": false
+        },
+    ]
+}

LICENSE

@@ -0,0 +1,9 @@
+The MIT License
+
+Copyright 2024 Loupe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,31 @@
+# Info
+This tool is provided by Loupe.  
+https://loupe.team  
+info@loupe.team  
+1-800-240-7042
+
+# Description
+
+This is an extension that connects Beckhoff PLCs into the Omniverse ecosystem. It leverages [pyads](https://github.com/stlehmann/pyads) to set up an ADS client for communicating with PLCs. 
+
+# Documentation
+
+Detailed documentation can be found in the extension readme file [here](exts/loupe.simulation.beckhoff_bridge/docs/README.md).
+
+# Licensing
+
+This software contains source code provided by NVIDIA Corporation. This code is subject to the terms of the [NVIDIA Omniverse License Agreement](https://docs.omniverse.nvidia.com/isaacsim/latest/common/NVIDIA_Omniverse_License_Agreement.html). Files are licensed as follows:
+
+### Files created entirely by Loupe ([MIT License](LICENSE)):
+* `ads_driver.py`
+* `BeckhoffBridge.py`
+
+### Files including Nvidia-generated code and modifications by Loupe (Nvidia Omniverse License Agreement AND MIT License; use must comply to whichever is most restrictive for any attribute):
+* `__init__.py`
+* `extension.py`
+* `global_variables.py`
+* `ui_builder.py`
+
+This software is intended for use with NVIDIA Omniverse apps, which are subject to the [NVIDIA Omniverse License Agreement](https://docs.omniverse.nvidia.com/isaacsim/latest/common/NVIDIA_Omniverse_License_Agreement.html) for use and distribution.
+
+This software also relies on [pyads](https://github.com/stlehmann/pyads), which is licensed under the MIT license.

exts/loupe.simulation.beckhoff_bridge/config/extension.toml

@@ -0,0 +1,37 @@
+[core]
+reloadable = true
+order = 0
+
+[package]
+version = "0.1.0"
+category = "simulation"
+title = "Beckhoff Bridge"
+description = "A bridge for connecting Omniverse to Beckhoff PLCs over ADS"
+authors = ["Loupe"]
+repository = "https://github.com/loupeteam/Omniverse_Beckhoff_Bridge_Extension"
+keywords = ["Beckhoff", "Digital Twin", "ADS", "PLC"]
+changelog = "docs/CHANGELOG.md"
+readme = "docs/README.md"
+preview_image = "data/preview.png"
+icon = "data/icon.png"
+
+[dependencies]
+"omni.kit.uiapp" = {}
+
+[python.pipapi]
+requirements = ['pyads']
+use_online_index = true
+
+[[python.module]]
+name = "loupe.simulation.beckhoff_bridge"
+public = true
+
+[[test]]
+# Extra dependencies only to be used during test run
+dependencies = [
+    "omni.kit.ui_test", # UI testing extension
+    "omni.usd",
+    "omni.kit.menu.utils",
+    "omni.physx"
+]
+timeout = 60

exts/loupe.simulation.beckhoff_bridge/docs/CHANGELOG.md

@@ -0,0 +1,4 @@
+Changelog
+
+[0.1.0] 
+- Created with based functionality to setup a connection and send/receive messages with other extensions.

exts/loupe.simulation.beckhoff_bridge/docs/README.md

@@ -0,0 +1,77 @@
+# Beckhoff Bridge
+
+The Beckhoff Bridge is an [NVIDIA Omniverse](https://www.nvidia.com/en-us/omniverse/) extension for communicating with [Beckhoff PLCs](https://www.beckhoff.com/en-en/) using the [ADS protocol](https://infosys.beckhoff.com/english.php?content=../content/1033/cx8190_hw/5091854987.html&id=).
+
+# Installation
+
+### Install from registry
+
+This is the preferred method. Open up the extensions manager by navigating to `Window / Extensions`. The extension is available as a "Third Party" extension. Search for `Beckhoff Bridge`, and click the slider to Enable it. Once enabled, the extension will be available as an option in the top menu banner of the Omniverse app.
+
+### Install from source
+
+You can also install from source instead. In order to do so, follow these steps:
+- Clone the repo [here](https://github.com/loupeteam/Omniverse_Beckhoff_Bridge_Extension).
+- In your Omniverse app, open the extensions manager by navigating to `Window / Extensions`.
+- Open the general extension settings, and add a new entry into the `Extension Search Paths` table. This should be the local path to the root of the repo that was just cloned. 
+- Back in the extensions manager, search for `BECKHOFF BRIDGE`, and enable it. 
+- Once enabled, the extension will show up as an option in the top menu banner. 
+
+# Configuration
+
+You can open the extension by clicking on `Beckhoff Bridge / Open Bridge Settings` from the top menu. The following configuration options are available:
+
+- Enable ADS Client: Enable or disable the ADS client from reading or writing data to the PLC.
+- Refresh Rate: The rate at which the ADS client will read data from the PLC in milliseconds.
+- PLC AMS Net ID: The AMS Net ID of the PLC to connect to.
+- Settings commands: These commands are used to load and save the extension settings as permanent parameters. The Save button backs up the current parameters, and the Load button restores them from the last saved values. 
+
+# Usage
+
+Once the extension is enabled, the Beckhoff Bridge will attempt to connect to the PLC.
+
+### Monitoring Extension Status
+
+The status of the extension can be viewed in the `Status` field. Here are the possible messages and their meaning:
+- `Disabled`: the enable checkbox is unchecked, and no communication is attempted. 
+- `Attempting to connect...`: the ADS client is trying to connect to the PLC. Staying in this state for more than a few seconds indicates that there is a problem with the connection. 
+- `Connected`: the ADS client has successfully established a connection with the PLC. 
+- `Error writing data to the PLC: [...]`: an error occurred while performing an ADS variable write. 
+- `Error reading data from the PLC: [...]`: an error occurred while performing an ADS variable read.
+
+### Monitoring Variable Values
+
+Once variable reads are occurring, the `Monitor` pane will show a JSON string with the names and values of the variables being read. This is helpful for troubleshooting. 
+
+### Performing read/write operations
+
+The variables on the PLC that should be read or written are specified in a custom user extension or app that uses the API available from the `loupe.simulation.beckhoff_bridge` module.
+
+```python
+from loupe.simulation.beckhoff_bridge import BeckhoffBridge
+
+# Instantiate the bridge and register lifecycle subscriptions
+beckhoff_bridge = BeckhoffBridge.Manager()
+beckhoff_bridge.register_init_callback(on_beckoff_init)
+beckhoff_bridge.register_data_callback(on_message)
+
+# This function gets called once on init, and should be used to subscribe to cyclic reads.
+def on_beckoff_init( event ):
+    # Create a list of variable names to be read cyclically, and add to Manager
+    variables = [   'MAIN.custom_struct.var1', 
+                    'MAIN.custom_struct.var_array[0]', 
+                    'MAIN.custom_struct.var_array[1]']
+
+    beckhoff_bridge.add_cyclic_read_variables(variables)
+
+# This function is called every time the bridge receives new data
+def on_message( event ):
+    # Read the event data, which includes values for the PLC variables requested
+    data = event.payload['data']['MAIN']['custom_struct']['var_array']
+
+# In the app's cyclic logic, writes can be performed as follows:
+def cyclic():
+    # Write the value `1` to PLC variable 'MAIN.custom_struct.var1'
+    beckhoff_bridge.write_variable('MAIN.custom_struct.var1', 1)
+
+```

exts/loupe.simulation.beckhoff_bridge/loupe/simulation/beckhoff_bridge/BeckhoffBridge.py

@@ -0,0 +1,107 @@
+'''
+  File: **BeckhoffBridge.py**
+  Copyright (c) 2024 Loupe
+  https://loupe.team
+
+  This file is part of Omniverse_Beckhoff_Bridge_Extension, licensed under the MIT License.
+
+'''
+
+from typing import Callable
+import carb.events
+import omni.kit.app
+
+EVENT_TYPE_DATA_INIT = carb.events.type_from_string("loupe.simulation.beckhoff_bridge.DATA_INIT")
+EVENT_TYPE_DATA_READ = carb.events.type_from_string("loupe.simulation.beckhoff_bridge.DATA_READ")
+EVENT_TYPE_DATA_READ_REQ = carb.events.type_from_string("loupe.simulation.beckhoff_bridge.DATA_READ_REQ")
+EVENT_TYPE_DATA_WRITE_REQ = carb.events.type_from_string("loupe.simulation.beckhoff_bridge.DATA_WRITE_REQ")
+
+class Manager:
+    """
+    BeckhoffBridge class provides an interface for interacting with the Beckhoff Bridge Extension.
+    It can be used in Python scripts to read and write variables.
+
+    Methods:
+
+        register_init_callback( callback : Callable[[carb.events.IEvent], None] ): Registers a callback function for the DATA_INIT event.
+
+        register_data_callback( callback : Callable[[carb.events.IEvent], None] ): Registers a callback function for the DATA_READ event.
+
+        add_cyclic_read_variables( variable_name_array : list[str]): Adds variables to the cyclic read list.
+
+        write_variable( name : str, value : any ): Writes a variable value to the Beckhoff Bridge.
+    """
+
+    def __init__(self):
+        """
+        Initializes the BeckhoffBridge object.
+        """
+        self._event_stream = omni.kit.app.get_app().get_message_bus_event_stream()
+        self._callbacks = []
+
+    def __del__(self):
+        """
+        Cleans up the event subscriptions.
+        """
+        for callback in self._callbacks:
+            self._event_stream.remove_subscription(callback)
+
+    def register_init_callback( self, callback : Callable[[carb.events.IEvent], None] ):
+        """
+        Registers a callback function for the DATA_INIT event.
+        The callback is triggered when the Beckhoff Bridge is initialized. 
+        The user should use this event to add cyclic read variables. 
+        This event may get called multiple times in normal operation due to the nature of how extensions are loaded.
+
+        Args:
+            callback (function): The callback function to be registered.
+
+        Returns:
+            None
+        """
+        self._callbacks.append(self._event_stream.create_subscription_to_push_by_type(EVENT_TYPE_DATA_INIT, callback))
+        callback(None)
+
+    def register_data_callback( self, callback : Callable[[carb.events.IEvent], None] ):
+        """
+        Registers a callback function for the DATA_READ event.
+        The callback is triggered when the Beckhoff Bridge receives new data. The payload contains the updated variables.
+
+        Args:
+            callback (Callable): The callback function to be registered.
+
+        example callback:
+            def on_message( event ):
+                data = event.payload['data']['MAIN']['custom_struct']['var_array']
+
+        Returns:
+            None
+        """
+        self._callbacks.append(self._event_stream.create_subscription_to_push_by_type(EVENT_TYPE_DATA_READ, callback))
+
+    def add_cyclic_read_variables(self, variable_name_array : list[str]):
+        """
+        Adds variables to the cyclic read list.
+        Variables in the cyclic read list are read from the Beckhoff Bridge at a fixed interval.
+
+        Args:
+            variableList (list): List of variables to be added. ["MAIN.myStruct.myvar1", "MAIN.var2", ...]
+
+        Returns:
+            None
+        """
+        self._event_stream.push(event_type=EVENT_TYPE_DATA_READ_REQ, payload={'variables': variable_name_array})
+
+    def write_variable(self, name : str, value : any ):
+        """
+        Writes a variable value to the Beckhoff Bridge.
+
+        Args:
+            name (str): The name of the variable. "MAIN.myStruct.myvar1"
+            value (basic type): The value to be written.  1, 2.5, "Hello", ...
+
+        Returns:
+            None
+        """
+        payload = {"variables": [{'name': name, 'value': value}]}
+        self._event_stream.push(event_type=EVENT_TYPE_DATA_WRITE_REQ, payload=payload)

exts/loupe.simulation.beckhoff_bridge/loupe/simulation/beckhoff_bridge/__init__.py

@@ -0,0 +1,11 @@
+# This software contains source code provided by NVIDIA Corporation.
+# Copyright (c) 2022-2023, NVIDIA CORPORATION.  All rights reserved.
+#
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto.  Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+#
+
+from .extension import *