mirror of https://github.com/OPCFoundation/UA-.NETStandard.git synced 2026-10-16 21:02:51 +08:00

Files

T

Marc Schier cef83550cb OPC UA Vision: a vision-guided bin-picking demo an LLM agent can see and drive (#4235 )

# Description

Implements **OPC UA — Vision** and uses it to build the demo the
companion specifications were drafted for: an eye-in-hand camera watches
a bin of parts, a language model *looks at the frame*, decides which
part matches the instruction, and commands the robot through Robot
Intent — with the OpenUSD viewer showing the arm move and the bin empty
out.

> **Draft, and stacked.**
[#4195](https://github.com/OPCFoundation/UA-.NETStandard/pull/4195) has
merged and master is merged in, so what is left on top of `master` is
the Vision work plus the unmerged `marcschier/ai-model-management`
branch, which the demo needs for the model/dataset/deployment
provenance. Review the Vision commits; the AI Model Management work
lands with its own PR.

## What is here

**The specification, implemented.** `Opc.Ua.Vision` is generated from
the spec's own `Opc.Ua.Vision.NodeSet2.xml`, vendored byte-identically
(SHA-256 `79C592C6…`, verified against a fresh download and stored
LF-preserved like the Robot Intent NodeSet). `Opc.Ua.Vision.Server`
builds the §4.2 discovery object, sensors, the coordinate-frame tree,
calibrations, media endpoints, inference pipelines and the §9 feedback
methods, with rendering and inference behind injectable providers.
`Opc.Ua.Vision.Client` is built on the generated ObjectType proxies and
composes transforms across the frame tree, which is what turns a
detection in camera coordinates into a pose a robot can act on.

**Two perception paths behind one contract**, which is exactly what
`InferenceLocationEnum` is for. `OnServer` is a deterministic detector
derived from the stage's ground truth — no model, no network, no GPU, so
CI can exercise the whole loop. `EdgeOffServer` is the agent: it sees
the frame over MCP and calls `SubmitDetections`, and the Server
publishes results it did not compute. A client reads
`DetectionResultType` identically either way.

**The agent's eyes.** `tools/Opc.Ua.Mcp.Vision` adds 22 `vision_*`
tools, which with the four shared connection tools makes the `vision`
profile 26; `vision_get_frame` returns the camera image as an MCP
`ImageContentBlock`, so the model looks at pixels rather than reading a
description of them. Tool profiles now compose — `--profile
vision,robotics` yields 62 tools — so one agent can both see and act
without dragging in the full 136-tool catalogue.

**The cell.** `samples/Robotics/BinPickingCell` follows the spec's own
Robotics-Vision Addendum: the `world → robot_base → flange →
gripper_tcp` frame tree with `camera_eih` on the flange, the `HandEye`
extrinsics and the `Intrinsics612x512` intrinsics — the addendum's
2448×2048 calibration scaled to the 4×4-binned grid the camera actually
delivers. `samples/Robotics/BinPickingClient` hosts the composed MCP
catalogue and optionally the viewer.

**Documentation.** `docs/Vision.md` (~800 lines) covers the model,
hosting, the build context, every topology builder, both perception
paths, feedback, the MCP profile and the limitations; linked from
`docs/README.md`, with the profile table in `docs/McpServer.md` and
READMEs for both samples.

## Evidence, not assertions

Each of these was measured on a running system rather than assumed:

| Claim | Evidence |
|---|---|
| The camera sees the bin | 612×512 frame with the bin and all five
parts in view — red `(212,47,47)`, green `(61,193,71)`, blue
`(54,85,218)`, yellow `(215,196,58)`, orange `(209,119,55)` |
| An agent can act on what it sees | Over MCP, `vision_get_frame`
returns a 612×512 PNG that decodes from base64 to 1,254,051 bytes, the
descriptor beside the detections says 612×512, and all five
`BoundingBox2D` centres land **inside** the frame on the pixel colour
their own detection claims |
| The geometry is right | A detection composed `camera_eih → world`
lands on the authored position, residual **0.0000 m** — on both the
on-server and off-server paths |
| The detector tracks the world | Placing a part drops the next scan
from 5 detections to 4, with that part absent |
| The robot obeys the agent | Scripted run took command authority and
completed a pick and a place, both `Succeeded` |
| Tool catalogues are honest | Counted from a running server: vision 26,
robotics 40, `vision,robotics` 62, full 136, **zero duplicates** |
| Every node is browsable by NodeId | Eight representative NodeIds —
both folders, a pipeline, a frame, the sensor, its Calibrations folder,
the HandEye calibration, the Media folder — all `Good` |

That tool-count check matters because the profile tests collapse names
into a `HashSet` and *cannot see* a duplicate registration — so the new
tests count registrations, not names.

## Things that were wrong, and are not now

Writing the tests found three defects of one kind — code that answered
instead of refusing. A zero-norm quaternion was silently rewritten to
identity, so a caller with an all-zero orientation got a confident wrong
grasp pose. `SubmitCorrection` rewrote a null `ResultId` to empty and
called the sink anyway. A bad `StageIdentifier` **killed the host
process** inside native `UsdStage.Open`, via an exception .NET cannot
catch. All three now refuse loudly and are pinned by tests.

**Nodes that existed but could not be reached.** The node manager
indexes the Vision root before configurators run, so everything the
fluent builder grafted on afterwards — both folders, the pipelines with
their Results and Feedback, the frames, the sensors with their optics,
calibrations and media endpoints — was never added to the index.
Browsing *forward from a parent* worked, because that walks
`NodeState.Children` in memory; browsing any of those nodes *by its own
NodeId* returned `BadNodeIdUnknown`, which is how an ordinary client and
the MCP discovery tools navigate. Registration is now deferred and
flushed after each configurator. The first fix covered only the DI path
and left the documented non-DI fallback broken in exactly the same way,
so `ConfigureVisionAsync` now exists and registers what it builds.

That defect survived a green suite because every test browsed children.
The new tests assert by NodeId, and were checked against the broken code
— with the flush removed, they fail.

**Every Method was uncallable.** The Server passed 426 unit tests while
not one of its Methods could be invoked over a real session —
`RunInference` returned `Bad_TooManyArguments`, and so did every other
Method that takes arguments, which is all of them but `StartContinuous`
and `Stop`. Three independent faults, each sufficient on its own: the
Method nodes were never created (they are Optional children, and the
dispatcher guards every attachment with a null check, so it silently
attached nothing); nothing declared the arguments, so the stack
concluded none were expected; and `MethodDeclarationId` pointed at a
synthesised NodeId rather than the NodeSet declaration a client calls
with, so the lookup missed the instance Method entirely. The builder now
creates the Methods, the `Results` folder and the `Feedback` object when
a provider or sink is configured, declares every signature, and names
the right declaration.

Unit tests could not have caught this: they invoke the handler delegates
directly and never go through `MethodState.Call`. It took an end-to-end
test over a real session. Relatedly, children created by the generated
`CreateOrReplace` helpers carry no `ReferenceTypeId`, so nothing could
reach them — fixed once in the build context rather than at the several
dozen call sites.
**And one where I was wrong.** Earlier in this branch I reversed my own
agents' decision and made `SubmitDetections` accept an empty detection
set, reasoning that "I looked and the bin is empty" is a correct
observation and refusing it forces a correct agent to invent a
detection. The reasoning is sound; it is also an argument *against* the
specification rather than an implementation of it. §9.5 is normative and
explicit — its StatusCode table lists `Bad_InvalidArgument` for
"`Detections` empty; or `SubmitCorrection` supplies both or neither
corrected array".

Worse, **none of §9.5's argument rules were enforced anywhere** — the
dispatcher forwarded every submission straight to the feedback sink, so
conformance depended on whichever sink a host installed. They are Server
obligations, so they now live in the dispatcher, ahead of the sink,
proven by strict mocks that would throw if the sink were consulted. The
usability problem is real and does not go away by conforming, so it is
raised where it can be fixed:
[opcua-drafts#70](https://github.com/marcschier/opcua-drafts/issues/70).

## Tracking the updated drafts

The Vision, Robot Intent and AI Model Management NodeSets on
`opcua-drafts` `main` have moved, partly because of feedback this branch
raised. All three are re-vendored byte-identically — verified by
comparing git blob hashes against the upstream files rather than by eye
— and the implementations follow.

**Two statements that were previously inexpressible now have a wire
representation.** `SubmitDetections` takes `SceneIsEmpty` and
`SubmitCorrection` takes `RetractAll`, so an agent can report "I
examined this frame and there is nothing in it" — the terminating
condition of the bin-picking task — and can retract a false positive by
correcting a result down to nothing. Both are checked in both
directions, because the flag is exactly what separates a deliberate
empty observation from a lost payload: an empty array without the flag
is refused, and the flag with an array attached is refused as two
contradictory claims about one frame. Implemented in the dispatcher, the
client, the MCP tools the agent drives, and the sample cell.

Also absorbed: `LampType` and `LightingMode` became enums (§66),
`ProfileName` became `DefaultProfileName` on the endpoint (distinct from
the `ProfileName` a caller passes to `GetStreamEndpoint`, which keeps
its name), AI `Invoke`/`InvokeAsync` gained `PayloadUri` under the same
exactly-one rule, and AI `ListModels` gained a `ContinuationPoint` —
because `MaxResults` alone puts everything past the bound permanently
out of reach.

**OpenUSD is on `0.9.0-alpha`**, verified on the running cell rather
than by restore alone: D3D12 backend, 612×512 frame, the bin and all
five parts in view and detected — the same result `0.8.0-alpha`
produced.

The one local workaround that survives is `VisionMethodArguments`, and
its reason has changed rather than gone away: the builder materialises
these Methods as Optional children through `CreateOrReplace`, which
constructs the state object directly and never runs the generated
factory that now carries the signatures. Checked rather than assumed —
removing the declarations fails five of the eight
`VisionMethodSurfaceTests`.

## Review feedback

Three threads, all addressed in `0fe2803a3`:

- **The AI Model Management work is now a library family, not a
sample.** `src/Opc.Ua.AI` (model), `.Inference` (`IInferenceBackend` and
backends), `.Server` (node manager) and `.Client` (discovery, reads,
calls, artefact transfer), in the same shape as the Robotics and Vision
families; the samples become `samples/AI/ModelManagementServer` and
`ModelManagementClient`. The client library needed real work rather than
relocation: its browsing surface was `private` inside the sample's
scenario runner, so moving the file alone would have produced a library
nobody could call.
- **No cloud-vendor SDK is referenced anywhere.** Inference goes through
`Microsoft.Extensions.AI` — an `IChatClient` is implemented by hosted
services and on-device runtimes alike, which is exactly the property
clause 8.1 asserts. `Azure.Identity` is gone: workload identity is not
an Azure feature, every platform projects a token into a file and each
SDK reads that file behind its own API, so the resolver reads it
directly. The comment claiming `Microsoft.Extensions.AI` would force a
`System.Text.Json` bump was stale — it pins 10.0.10, which this
repository already centralises on.
- **`BinPickingCell` and `BinPickingClient` moved into
`samples/Robotics/`**, which is where they belonged: the cell was
already linking the arm, its kinematics and both USD assets out of
`IntentEnabledRobot`.

## Upstream

Work that belonged elsewhere went elsewhere rather than being worked
around locally:

- **`openusd-dotnet`
[#13](https://github.com/marcschier/openusd-dotnet/pull/13)** — merged
and shipped in `0.8.0-alpha`. `SilkFrameCapture.Capture` rendered only
the first capture of a session and silently returned a blank frame for
every one after it. Also filed
[#14](https://github.com/marcschier/openusd-dotnet/issues/14) (no
camera-by-prim API) and
[#15](https://github.com/marcschier/openusd-dotnet/issues/15) (skipped
tests reported as passed — which fooled me for several runs). Both are
fixed; this branch takes `0.8.0-alpha` and deletes two workarounds,
including 143 lines of hand-rolled projection maths.
- **`opcua-drafts`
[#66](https://github.com/marcschier/opcua-drafts/issues/66)–[#69](https://github.com/marcschier/opcua-drafts/issues/69)**
— a close read of the spec produced 22 candidate ambiguities; 12 were
discarded as misreadings with clause citations and the remaining 10
filed. One is concrete: five members exist in the NodeId CSV that no
clause documents.
- **`opcua-drafts`
[#70](https://github.com/marcschier/opcua-drafts/issues/70)** — §9.5
could not express an empty observation or a false-positive retraction.
**Adopted**, with the explicit-flag resolution argued for:
`SubmitDetections` gained `SceneIsEmpty`, `SubmitCorrection` gained
`RetractAll`, and the corrected-array rule relaxed from *exactly one* to
*at most one*.
- **`opcua-drafts`
[#71](https://github.com/marcschier/opcua-drafts/issues/71)** — the
Vision NodeSet browse-named all 13 `InputArguments` / `OutputArguments`
Properties in the Vision namespace rather than the base namespace, so a
stack could not find them and every Method in the specification was
uncallable. **Fixed**; this branch now tracks the corrected artefact.

## The defect underneath it all

The end-to-end suite was removed earlier in this branch because nine of
its
fourteen tests failed on one symptom: a client could not open a
pipeline's
`Feedback` object or enumerate its `Results`, even though browsing the
same
parent listed both. Restoring it meant explaining that, and the
explanation
was not in Vision.

`RelativePathElement` initialised **`IsInverse` to `true`**. A caller
that
sets a `ReferenceTypeId` and a `TargetName` — which reads as *"the child
reached by this Reference"* — was therefore asking the Server for the
**inverse** Reference, and got `Bad_NoMatch` with nothing in the request
to
suggest why.

`ObjectTypeClient.ResolveChildNodeIdAsync` is such a caller, and it is
what
**every source-generated Optional-child accessor in the stack** is built
on
— the accessor whose own documentation cites
`AlarmConditionTypeClient.GetShelvingStateAsync`
as an example. Vision is merely where it surfaced, because Vision puts
two
Optional children on the path an off-Server agent must take. The sibling
helper in `StateMachineTypeClientExtensions` already set `IsInverse =
false`
by hand, which is the shape of a trap rather than a default.

The default is now forward, `ResolveChildNodeIdAsync` says so
explicitly,
and the existing test that had recorded `true` as *expected* now pins
`false` with the reasoning. Of the forty `RelativePathElement`
construction
sites in the tree, that accessor was **the only one relying on the
default at
all** — every deliberate caller already set it.

Two further defects were found underneath it, both real and both fixed:

- The generated `CreateOrReplace` helpers construct a child state object
directly and leave **`TypeDefinitionId`** unset as well as
`ReferenceTypeId`.
A child referenced by nothing cannot be browsed; one with no type
definition
is a malformed Object that a client filtering by type silently skips —
which
  is exactly what `EnumerateResultsAsync` does. Normalisation moved to
`VisionNodeManager`, so it also covers the case the builder cannot see:
a
result published **at runtime** by an inference provider, long after the
address space was built. That path produced results a client could list
but
  not read.
- `Opc.Ua.AI` shipped without an `AssemblyInfo`, so the solution built
with
  six `CA1014` warnings.

I had initially "fixed" this in the Vision client with Browse-based
fallbacks,
on the strength of a probe that appeared to show
`TranslateBrowsePathsToNodeIds`
failing even for `Server → ServerStatus`. That probe was wrong: it used
an
unqualified `ReferenceTypeIds`, which inside a `Opc.Ua.Vision.*`
namespace
binds to *Vision's* `ReferenceTypeIds` and yields a nonsense NodeId.
Chasing
that to the end is what turned up the real cause. **The fallbacks are
gone** —
they would have hidden a stack-wide bug behind a Vision-shaped
workaround, and
one of them matched on browse name while ignoring the namespace index.

`tests/Opc.Ua.Vision.Intent.Tests` is restored and back in `UA.slnx`,
passing
**14/14** on its own merit rather than through a client-side workaround.
A
registration test now pins the pipeline's `Feedback` and `Results`
children,
which nothing covered before.

## Running it, and what that found

The demo's premise is that a language model **looks at the bin and
reasons
about what it sees**. Running it end to end showed it could not, for
reasons
no test covered, because every one of them lived between components.

**The sample did not compile.** Two `CS8604` nullable errors with
`TreatWarningsAsErrors`, so neither the cell server nor the demo could
be
started at all. Worth recording that my first explanation was wrong: CI
*does*
build this project - the Linux leg's `net10.0` pass compiles it,
log-confirmed -
so this is not a coverage gap in the workflow, and no workflow change
was made.

**`Pick` and `Place` never moved the arm.** They were a delay plus a
gripper
action, so the operations reported `Succeeded` while nothing travelled.
They now
solve IK once and interpolate in joint space. **And the parts never
moved**: the
arm swung but the bin stayed full, because nothing tied the held object
to the
world state. The connector now creates 11 monitored items where it
created 6,
and a scripted run delivers `SeqNo=151` across 10 messages where it
delivered
`SeqNo=3` across 1.

**The frame was smuggled through a string field.** The media provider
put a
base64 *data URI* of the PNG into `VisionImageReferenceDataType.Uri` - a
field
meant to be a *reference*, while the bytes were already returned in the
inline
`ByteString`. Every response therefore shipped the image twice, and a
1,311,400-byte PNG became a 1,748,536-character string against a
`MaxStringLength` of 65,535: **26.7x over**. That is why raising
`MaxByteStringLength`, `MaxArrayLength` and `MaxMessageSize` never
helped - none
of them govern a `String`. Separately the MCP tool assigned raw bytes
where
`ImageContentBlock` requires base64, so the wire carried
`"data":"�PNG..."` -
every non-UTF-8 byte replaced by U+FFFD, destroying the image and
inflating the
response to 6.8 MB.

**The camera was aimed at nothing.** The arm's home pose, the flange
scan pose
the Vision model declared and the joint angles in the USD stage were
three
independent claims about where the camera was, and they disagreed - the
declared
flange orientation pointed the view 86 degrees away from the projection
camera.
Solving them as one thing exposed two further constraints that are easy
to miss:
the camera has to sit off the tool axis or it photographs its own
gripper, and
the IK branch has to be elbow-back or a link parks under the camera and
fills the
frame with the arm's own upper arm. A third was a regression this branch
introduced and `Opc.Ua.Robotics.Tests` caught - aiming a straight-down
camera
from a point on the base's own X-Z plane puts the wrist on the J4/J6
singularity, so every motion away from home fails to solve. A 15-degree
camera
roll, free because the camera still looks straight down, gets 25 degrees
clear,
which is the margin the poses before this branch had.

**The frame and the detections were different images.** The sensor
declared
2448x2048, the clip endpoint 1280x1024, and the renderer produced
640x512 - not
even the same aspect ratio. The ground-truth detector projects through
the
declared intrinsics, so its boxes lived in 2448x2048 space while an
agent was
handed a 640x512 picture: *"pick the red cube you can see"* arrived with
coordinates that pointed off the image. Everything now agrees at
612x512, an
exact 4x4 bin of the native sensor with the intrinsics scaled to match;
the
native size stays in the model and serial number, where it describes the
hardware rather than the image.

**`LatestClip` was created and never written**, so it reported
`Bad_NoDataAvailable` for the life of the Server and a consumer
following the
model - read the published frame, call the method only if there is none
- never
got a frame. The dispatcher now publishes a clip it has just encoded,
for every
Vision server rather than this sample alone.

One genuine API gap turned up on the way: `OpcUaServerOptions` exposes
`MaxByteStringLength`, `MaxArrayLength` and `MaxMessageSize` and **no
`MaxStringLength`**, so a Server that legitimately needs a long string
could not
raise the limit through the hosting API at all. Added, with tests. It is
not the
fix for anything above - that was a design bug - but the missing knob
was real.

## Not finished

- **Two projects sit below the repository's 80% line coverage.**
`Opc.Ua.Vision.OpenUsd` is at 71.1% — what is left only executes with a
real OpenUSD stage and plugin tree, which is not on every build agent.
`Opc.Ua.AI.Inference` is now at **86.7%**, up from 12.9%: the code this
branch *wrote* is covered by 25 tests, and `RestChatCompletionsBackend`
— previously the whole of the shortfall — is covered by 18 more against
a stubbed `HttpMessageHandler`, exercising success, refusal, throttling,
retry-after, timeout and cancellation without a network. Everything else
clears the bar — `Opc.Ua.Vision.Server` 92.1%, `Opc.Ua.AI` 91.4%,
`.Vision.Client` 88.1%, `Opc.Ua.Vision` 85.7%, `Opc.Ua.AI.Server` 80.1%,
all measured with coverlet. The CI coverage gate reports itself as
advisory and non-blocking.
- **`SamplesCollected` is not counted here, and `docs/Vision.md` now
says so.** Section 9.4 requires a Server to count a negative example
(`SceneIsEmpty` / `RetractAll` carrying a `GroundTruthLabel`) exactly as
it counts one carrying geometry. `VisionNodeManager` does not, and
structurally cannot: `SamplesCollected` is a property of
`LearningJobType`, which the *AI Model Management* companion defines,
and Vision reaches the job through a `NodeId` value rather than a
Reference **precisely so this model takes no dependency on the model
that defines it**. What the Server does guarantee is that the negative
example survives the hop intact — both flags are carried verbatim to
`IVisionFeedbackSink` — so a host that binds a learning job has
everything it needs to satisfy the clause on the counter it owns. Stated
in the limitations rather than left implied.

## Related Issues

Was stacked on #4195, now merged. No tracking issue yet for the Vision
implementation itself — happy to open one if you would like the design
recorded as an ADR before this goes further.

## Checklist

- [x] I have signed the
[CLA](https://opcfoundation.org/license/cla/ContributorLicenseAgreementv1.0.pdf)
and read the
[CONTRIBUTING](https://github.com/OPCFoundation/UA-.NETStandard/blob/master/CONTRIBUTING.md)
doc.
- [x] I have added tests that prove my fix is effective or that my
feature works and increased code coverage. — *Types 8562, Server 4072,
Client 2123, InformationModel 1063, Robotics 540, Tools 466, Vision 442,
AI 74 and the restored Vision+Intent end-to-end suite 14/14, all green
on net10.0. Only `.OpenUsd` (71.1%) is below the 80% bar — see Not
finished.*
- [x] I have added all necessary documentation.
- [x] I have verified that my changes do not introduce (new) build or
analyzer warnings. — *`dotnet build UA.slnx -c Release`: 0 errors, 0
warnings.*
- [x] I ran **all** tests locally using the **UA.slnx** solution against
at least .net **framework** and .net **10**, and all passed. — *net48:
Types 8555, Client 2126, Vision 385 green. Two net48 Server tests fail
(`CreateUserManagementSeamBindsTheModelToTheServerAsync`, and
`DurableDataValueQueueVerifyReferenceBatchingAsync` only under parallel
load); both were confirmed **pre-existing** by re-running them with the
`IsInverse` change reverted, which fails identically.*
- [ ] I fixed **all** failing and flaky tests in the CI pipelines and
**all** CodeQL warnings. — *The net48 build legs failed because the
restored end-to-end project used `ValueTask.FromResult` /
`string.Create`, which do not exist on .NET Framework; fixed in
`fb57522da` and verified building on every TFM.
`DisposeDrainsHeldConnectionCallbackBeforeListenerDisposal` failed once
on the Ubuntu Client leg — a 13 ms timing-sensitive reverse-connect
disposal test that passes locally 2123/2123 and touches no browse
paths.*
- [ ] I have addressed **all** PR feedback received.
## Typed Vision-guided Robotics MCP workflows

The branch now also makes the demo workflow first-class in the Full MCP
profile:

- replaces stringified Robotics intent and mission inputs with typed
request schemas and exact name-or-NodeId selectors;
- adds bounded operation/mission paging, stable step-to-operation
identity, retained mission discovery, and `robotics_wait_mission`;
- makes `vision_run_inference` return bounded typed detection,
inspection, or segmentation summaries in one call;
- adds same-session `robotics_vision_pick` to select a detection and
submit Pick or Pick/Place work without implicitly taking authority,
retrying, cancelling, or waiting; and
- starts Publish workers for classic subscriptions so an independently
launched OpenUSD viewer receives live robot and part updates.

The migration guide documents the intentionally breaking MCP
request-schema changes.

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 1dab1302-19c5-4a9b-a50c-d97d389713aa
Copilot-Session: a248a589-9a20-4372-868e-5d347e57001b
Copilot-Session: 99d1ab42-f83a-41ab-bf3e-85bf81fadace
Copilot-Session: bcbc8ac9-5abd-42a8-8bac-e10533790e2e

2026-08-29 19:34:15 +02:00

16 KiB

Raw Blame History

MinimalRobotServer

A minimal, self-contained .NET console OPC UA server that demonstrates the OPC 40010 Robotics, OPC 10000-210 Relative Spatial Location, and OPC 10000-211 Global Positioning companion specifications bound to OpenUSD through the draft OpenUSD binding companion model, so a generic connector renders a robot cell live with no robot-specific code. It is built on the Opc.Ua.Robotics and Opc.Ua.OpenUsd SDK libraries. See docs/Robotics.md for the Robotics developer guide and docs/OpenUsd.md for the OpenUSD binding.

It is the Robotics counterpart of PumpDeviceIntegrationServer and is validated end-to-end by RobotOpenUsdE2eTests (in tests/Opc.Ua.Di.Tests).

What it exposes

A MotionDeviceSystem "RobotCell" (prim /Cell) composed recursively of:

Two 6-axis articulated robots (MotionDeviceType R1, R2 → /Cell/Robots/R1, /Cell/Robots/R2), aggregated 1..n with a Many / Reference <Component> binding (Reference — not Instance — so each robot articulates independently).
Six axes per robot (AxisType A1..A6), aggregated with a nested Many / Child <Component> binding. Each Axis' ParameterSet/ActualPosition (degrees) drives one joint xformOp:rotate{Z|Y|X} on the (pre-authored) robot.usda kinematic chain — the live articulation (RenderTargetKind = Rotation). The axis limits are those of the reference robot (see below). The axis values come from an arm solver, so the arm genuinely reaches the slot it is working rather than replaying a canned pose list.
A cell EmergencyStop safety state driving a beacon and per-robot warning halo visibility (UaAlarmToUsd, Visibility).
An opt-in SpeedOverride command (UsdToUaCommand, fail-closed).
A gripper tool on each robot's flange, plus one mounted on R1 at runtime (One / Reference, Dynamic = true) via a model-change event. R1 carries a NodeVersion property so that mounting it is reportable at all — see Dynamic components need a NodeVersion.
A CellTwin folder under Objects carrying the state that is neither a device nor an axis: a ThreeDCartesianCoordinates position and a ThreeDOrientation heading per workpiece, driving /Cell/Parts/PartNN (Translation and Rotation), and a jaw position per robot driving …/Flange/Tool/Jaw{Upper|Lower}. Without these the choreography is invisible — the robots mime a transfer while the blocks stay wherever the asset authored them.
One RSL spatial-object list with a world frame, R1/R2 SpatialObject AddIns, each robot's PositionFrame, and R1's ToolFlange AttachPoint.
One GPOS Zone with ground-control points and one live GlobalLocation per robot. Both poses come from the shared CellChoreographer, so the robots agree on where each other is - see The transfer cycle.

All 15 representations (1 system + 2 robots + 12 axes) are discoverable through the well-known Server/OpenUSD/Representations registry.

The transfer cycle

R1 collects a part from the western station (WorkTableA) and delivers it to the eastern one (WorkTableB); R2 collects from the east and returns it to the west. Three parts circulate, so both robots usually have work.

Keeping them apart

The cell is divided into reservable zones:

Zone	Extent	Occupancy
`EndZoneA` / `EndZoneB`	\|x\| > 1.3 m	one robot — a deployed arm needs the whole end
`CorridorEastbound`	\|x\| ≤ 1.3 m, northern lane (y = 0.35)	one robot
`CorridorWestbound`	\|x\| ≤ 1.3 m, southern lane (y = −1.15)	one robot
`DockA` / `DockB`	around each charging dock (y = −2.0)	one robot

A robot reserves the zone immediately ahead before entering it and releases the one behind once it is clear — block signalling, not a global schedule. Three rules follow:

Two robots travelling opposite ways pass, because they are in different lanes 1.5 m apart. Two travelling the same way queue instead of overtaking.
An arm may only leave its transport envelope inside an end zone, which the robot holds exclusively. This is the rule that fixes the original defect.
A robot with no work parks on its dock, releasing the end zone so the other robot can deliver into the station it serves. Without this the cell deadlocks on the first handover — an idle robot standing by its table blocks the delivery it is waiting for.

The docks sit in a southern layby rather than beside the stations, because a robot parked next to a station is close enough to foul a robot turning into it.

What else is simulated

Trapezoidal travel — accelerate, cruise, brake into the stop, with the heading following the path.
Speed and separation — travel speed drops near the other robot, and the cell emergency stop now halts motion rather than only blinking the beacon.
Battery and charging — charge drains with distance; below the threshold the robot finishes its delivery, docks, charges and resumes.
Grip faults — a seeded slip occasionally drops a part; the robot re-picks it off the floor. Deterministic, so the recovery path is testable.
KPIs — parts moved, cycle count, last and average cycle time, utilisation, fault count.

The invariants are asserted rather than assumed: CellChoreographyTests runs ten minutes of simulated time and checks on every 50 ms step that the oriented footprints never overlap, that a zone is never doubly occupied, that arms only deploy in an end zone, that parts are conserved, and that a carried part sits exactly on the tool centre point.

Where the part actually is

A carried part's pose is computed by forward kinematics from the same six axis values the server publishes (RobotKinematics), not from the script that produced them. That is what keeps it welded to the gripper: if the arm and the part were computed independently they would drift apart. RobotArmSolver is checked against that same forward kinematics, so the arm provably reaches each slot to within a micrometre.

It is computed from the platform pose that was last published, not the one the simulation currently holds. The platform and the workpiece leave the server as separate bindings, and publishing them from loops running at different rates floated the part a quarter of a metre out in front of the jaws while the robot drove — three part widths, and the first thing anyone notices in a viewport. RobotOpenUsdE2eTests rebuilds the tool centre point from the values authored into the scene and asserts a carried part sits on it.

The buffers are worked first-in-first-out. Collecting the lowest free slot instead starves any part that never lands in it: with two parts seeded on WorkTableA, the second sat untouched for the life of the process while the robots shuttled the other one past it.

Editing a live-bound prim

Every prim the server drives declares exactly one matrix4d xformOp:transform and orders only that op — the parts and the gripper jaws included. A viewer composes the translate and rotate ops it receives into that single matrix, and an op order declared in a referenced asset sits in a weaker layer than the one a connector edits, so it could not be cleared from there. RobotAssetContractTests asserts this for every bound prim.

The gripper jaws are one Xform each, owning their carrier and their finger. Driving the carrier alone would slide it out from under the finger it is bolted to.

Dynamic components need a NodeVersion

Part 5 §9.32.2 allows only a node that carries a NodeVersion property to trigger a ModelChangeEvent, and AsyncCustomNodeManager drops entries for nodes that lack one. A Dynamic component binding is reconciled from those events, so the node whose references change — here the robot the tool is mounted on — has to expose NodeVersion, via EnableModelChangeTracking. Without it the mount is filtered out and no client is ever told the gripper appeared.

The failure this caused was quietly asymmetric, which is worth knowing about. Removal kept reporting, because a deleted node is no longer in the manager's index and so takes the "not mine, pass it through" branch of the filter; only addition was dropped. A connector that happened to start while the tool was mounted therefore looked correct and could still deactivate it, while one that started in the six-second gap never composed the tool at all and never recovered.

DynamicToolIsComposedAsync asserts the transition — the prim observed both active and inactive across more than one full cycle — rather than a momentary state, so it cannot pass on a connector that only ever hears about one direction.

The opening view

The cell authors /Cell/OverviewCamera and a connector opens on it, because framing the bounds of an enclosed scene automatically puts the eye inside the fence, looking at whichever robot happens to be nearest. The first camera in the served root layer wins, so the establishing shot is authored before /Cell/TopDownCamera; --camera overrides the choice outright. RobotAssetContractTests asserts the ordering.

Ideas for more realism

Natural extensions that are deliberately not implemented, roughly in order of value:

Speed-and-separation monitoring to ISO 10218 / TS 15066, with a modelled protective field, replacing the simple proximity speed scale.
Sensor cones on the existing ScannerFront / ScannerRear prims, with detections driving the slowdown instead of omniscient positions.
A tool changer — dock the gripper and pick up a different end-effector, which the dynamic-component binding already demonstrates the mechanics for.
An inspection station that rejects a part, giving the routing a real branch.
Conveyor infeed and outfeed instead of a fixed part population.
Operator gate interlock — opening the front gate stops the cell.
Joint torque and current telemetry, plus thermal drift, so axes carry more than position.
Maintenance counters (distance travelled, grip cycles) feeding a service alarm.
Time-sampled pose history so a viewer can scrub the last cycle rather than only following live values.
Traffic priority — today a blocked robot simply waits; a real fleet manager would weigh deadlines and re-route.

The USD assets

Assets/robot.usda, Assets/tool.usda and Assets/Cell.usda are embedded in the server and served over Part 5 FileType with SHA-256 digests, so a connector can fetch the whole closure and render the twin without any external asset resolver.

Reference robot — KUKA KR 16-2

robot.usda reproduces the published kinematics of a KUKA KR 16-2, taken from the ROS-Industrial URDF (ros-industrial/kuka_experimental, kuka_kr16_support):

Joint	Offset from the previous axis	Rotate op	Limit
A1	675 mm up from the mounting face	`xformOp:rotateZ`	±185°
A2	260 mm forward	`xformOp:rotateY`	−155°…+35°
A3	680 mm along the upper arm	`xformOp:rotateY`	−130°…+154°
A4	670 mm along the forearm, −35 mm lateral	`xformOp:rotateX`	±350°
A5	coincident with A4	`xformOp:rotateY`	±130°
A6	coincident with A4	`xformOp:rotateX`	±350°
Flange	158 mm past the wrist centre	—	—

260 + 680 + 670 = 1611 mm, the robot's published reach. A4, A5 and A6 are coincident, which is the real spherical wrist. The livery is KUKA orange over dark cast housings, and the cell is scaled around that reach: a 7.2 × 4.8 m floor with the guarding at x = ±3.4 m, y = ±2.2 m, plus a controller cabinet, two transfer stations, two charging docks and a stack light.

Mobile platform

Each arm rides on an omnidirectional AGV (/Robot/MobileBase, 1.10 × 0.72 m, 365 mm deck) in the style of a KUKA KMP: orange chassis, dark skirt, four wheels, diagonally opposed safety scanners, bumpers and status strips. The RSL scenario drives each robot's spatial location across the cell, so the arm has to be carried rather than bolted to the floor.

Platform clearance is not enough on its own. An earlier version of this sample ran the two robots on independent figure-eight paths and claimed the footprints cleared. They did — by 1.2 m at closest approach — but the arms reach 1.611 m, so they swept straight through each other. Clearance has to be argued about the deployed arm, not the chassis, which is why the cell is now zoned and the arm must be stowed to travel.

To floor-mount the arm instead, delete /Robot/MobileBase and clear the xformOp:translate on /Robot/Base; nothing else depends on it.

Editing the assets

The prim paths and rotate ops above are the binding contract: RobotCell.cs addresses them by name, and the connector writes each joint rotate op as a scalar double. Link offsets, geometry, materials and lighting are all free to change; the paths, op names, xformOpOrder entries, /Robot/Base/.../Flange, /Robot/Warning, /Cell/SafetyBeacon, /Cell/Parts/PartNN, /Gripper/Jaw{Upper|Lower}, /Cell.inputs:speedOverride and the R1/R2 mount attributes are not.

RobotAssetContractTests (in tests/Opc.Ua.OpenUsd.Tests) parses the shipped assets and asserts that contract, so an edit that breaks it fails the build instead of silently freezing the twin. Note that the .usda files under tests/Opc.Ua.OpenUsd.Tests/Assets are a frozen reader/materializer fixture and are deliberately not kept in sync with these assets.

Author with real USDA syntax: the managed UsdaReader is more forgiving than OpenUSD itself, so a layer that parses in the tests can still fail to load in a viewer. The end-to-end run below is the authoritative check.

Design note — stock Robotics hosting

The server uses the stock Opc.Ua.Robotics.Server hosting pipeline:

AddRobotics() registers the sealed stock RoboticsNodeManager, DI/IA/Robotics model provider, and the shared Robotics configurator pipeline.
AddRoboticsModel<OpenUsdModelProvider>(), AddRoboticsModel<RslModelProvider>(), and AddRoboticsModel<GposModelProvider>() contribute the additional compiled OpenUSD, RSL, and GPOS companion models to the same manager.
ConfigureRobotics<RobotCell>() builds the cell with the validated fluent topology builders (AddMotionDeviceSystemAsync, AddMotionDevice, AddAxis, safety, controller, task-control, and operation builders).
AddPositioningFor<RoboticsNodeManager>() and ConfigurePositioningFor<RoboticsNodeManager>(...) add the RSL/GPOS spatial objects, frames, attach point, zone, and live global-location bindings after the Robotics topology exists.

The OpenUSD facility still lives under the standard Server/OpenUSD entry point, but it is now authored by the RobotCell configurator against the stock manager instead of by subclassing a custom node manager.

Run it

dotnet run --project samples/Robotics/MinimalRobotServer -- --host localhost --port 62830

Then drive it with the same generic connector used for pumps (Opc.Ua.OpenUsd.Connector) to author a live USD override layer:

dotnet run --project tools/Opc.Ua.OpenUsd.Connector -- \
    --server opc.tcp://localhost:62830/MinimalRobotServer \
    --out <path>/live.usda --insecure --seconds 10

Compose live.usda over the base Cell.usda (see the example stage.usda) and open it in usdview / NVIDIA Omniverse to see the two arms articulate live. The example USD assets, descriptor, writer, and a step-by-step guide live alongside the OpenUSD binding specification, under its examples/robotics/ directory.

To watch the cell animate without leaving the connector, install the optional Opc.Ua.OpenUsd.Connector.Viewer assembly beside it and add --view:

dotnet run --project tools/Opc.Ua.OpenUsd.Connector -- \
    --server opc.tcp://localhost:62830/MinimalRobotServer --insecure --view

That fetches this server's served asset closure, composes stage.usda, opens a viewport, and streams the same subscribed values into both the override layer and the rendered stage, so the joints move on screen as the simulation runs. See docs/OpenUsd.md.

The robot motion is configured through RobotMobilityOptions. RSL Position/Orientation values author xformOp:translate and xformOp:rotateXYZ; GPOS longitude, latitude, and elevation author the inputs:longitude, inputs:latitude, and inputs:elevation attributes. See docs/Positioning.md.

16 KiB Raw Blame History Unescape Escape