UCI: A common mission message model
Part of the Open Architecture Field Guide.
The Universal Command and Control Interface (UCI) defines a common message model for mission-level command and control. Its value is a shared description of tasks, capabilities, state, and reports across system boundaries.
In this guide
Giving a task the same meaning at both ends
Suppose one component asks another to perform a task. Delivering the bytes is only the beginning of the exchange. The recipient needs to know what is being requested, which object or capability the request concerns, and how subsequent status reports relate to it. The sender needs to distinguish acceptance, progress, completion, and failure in a form it can use.
If every pair of components defines these concepts independently, each new connection introduces another translation problem. Two systems may use different identifiers for the same object or attach different meanings to similarly named states. Integration then requires understanding and reconciling both models.
The Universal Command and Control Interface (UCI) supplies a common message model for mission-level command and control. It defines structures through which participants describe capabilities, tasks, state, and observations. Developers can use a shared set of concepts when specifying exchanges between components instead of inventing a new vocabulary for each connection. [1]
From a message structure to a complete interaction
A schema is a formal definition of data structures: their fields, permitted types, and relationships. It lets tools and developers determine what a message can contain. A structured identifier, for example, allows later messages to refer to an object without repeating its entire description.
The schema becomes useful in an interaction when the participants agree on how those objects are used. Consider an illustrative sequence in which a requester selects an available capability, sends a task request, and receives status followed by a result. The request and reports need enough shared context to associate them with the same work. Their meaning depends on both the message definitions and the behavior assigned to the participating components.
This distinction explains why interface engineering includes more than a list of message fields. The team also describes which component sends each message, the circumstances in which it sends it, and what the recipient is expected to do. A completion report, for instance, has meaning because it refers to an identified task whose state has changed.
UCI gives that work a common model. The program applies the relevant parts of the model to its actual functions, then tests the exchanges through the states that the integration is expected to support. [1]
How UCI relates to OMS and DDS
UCI is commonly encountered with Open Mission Systems (OMS). OMS defines a mission-system integration boundary; UCI defines the message content used in mission-level exchanges. A component can expose an OMS interface through which it receives and produces UCI messages. The two descriptions concern different aspects of the same interaction. [2]
The communication software has another responsibility: delivering information between participants. Middleware such as Data Distribution Service (DDS) provides data-distribution services over the available network. In the task example, the message model defines the information sent, while the middleware carries the resulting updates to their consumers.
This gives the engineering team a practical way to locate a problem. If the recipient cannot interpret what a status field means, the question concerns the message model and its application. If the update arrives too late, the investigation follows the communication path and delivery policies. If the component's responsibilities are unclear, the integration architecture needs attention.
Using a common model as the system grows
The benefit becomes more apparent when another consumer needs the same report. With an established message model, the new component can be designed around objects and relationships that the system already uses. The producing component's internal algorithm can remain separate from the representation through which it communicates its result.
The integration still has a concrete design to document: the applicable message definitions, participating components, and expected behavior over the exchange. Those details turn the shared vocabulary into a usable interface. The DDS chapter continues from this point by explaining how applications publish and receive the data once its meaning has been defined.
References
- OACWG / AFLCMC, UCI Standard OAC-STD-001 v2.5: Definition and documentation set.
- OACWG / AFLCMC, Open Mission Systems Standard v2.5: Definition and documentation set.