MORA: Interfaces for shared RF resources
Part of the Open Architecture Field Guide.
The Modular Open RF Architecture (MORA) defines interfaces for sharing radio-frequency resources. It separates the functions that use those resources from the hardware and services that provide them.
In this guide
Separating an RF function from the equipment it uses
A radio-frequency (RF) application works with equipment that connects electromagnetic signals to digital processing. An antenna couples energy to or from the environment. Front-end electronics condition or convert the signal, and processing equipment operates on the resulting data. In a dedicated system, these stages may be controlled as one tightly connected chain.
That arrangement makes the resource relationship simple for one function: it owns the chain it uses. Reusing the same equipment for another function creates a different problem. The new function needs to discover what the resource can do, request the relevant configuration, and exchange data through an interface that both sides understand.
The Modular Open RF Architecture (MORA) addresses this boundary. It defines common control and data interfaces around RF resources, separating the application that uses a resource from the implementation that provides it. The Army includes MORA within the wider CMOSS suite of standards. [1]
Control describes use; data carries the observation
The control interface concerns the resource's state and configuration. The data interface carries the signal information being processed. Keeping these roles distinct allows the system to describe both what the application has requested and what information it receives as a result.
Consider an illustrative sensing application that uses a receiver resource. Before processing observations, it needs the resource to be available in the required configuration. Once that relationship is established, the application consumes the data provided through the corresponding interface. Status information allows it to relate the arriving data to the state of the resource that produced it.
This sequence makes an otherwise hidden dependency explicit. The application's algorithm operates on observations, but those observations depend on equipment configuration and availability. The interface connects the processing task to those conditions without requiring the application to contain every device-specific control mechanism.
Sharing introduces an allocation problem
Two applications may request the same resource at the same time. Their requests may be compatible, or they may require settings that the hardware cannot provide together. Sharing therefore requires a system-level decision about which requests can be supported with the available equipment and priorities.
The architecture exposes the relationships through which that decision is implemented. The resource provider supplies defined capabilities and reports its state. Applications request and use resources through the common interface. The system's allocation logic coordinates demand with what can actually be supplied.
This division is useful when a resource changes. A replacement device can present the required control and data behavior while using a different internal implementation. The application remains concerned with the service it needs; the resource integration handles the details of the equipment providing it.
The connection to CMOSS and OpenVPX
MORA fits within a broader platform design. CMOSS combines modular hardware, vehicle networking, software, and RF interfaces. OpenVPX describes connections among plug-in modules and their backplane. MORA describes how an application accesses RF resources within that environment. [1]
A physical connection and a resource interface therefore answer different questions. The hardware design establishes how equipment is connected and supported. The MORA interface describes the control and data relationship through which a function uses that equipment. Following both views shows how an application request reaches a resource and how the resulting information returns to the application.
For the receiver example, this gives the integration team a concrete path to examine: the requesting application, the allocation of the receiver, its configuration and state, and the data supplied for processing. Each step has a role in the function, and each role belongs to an identified part of the system.