Geon is proud to announce the release of an innovative solution called vrtgen that simplifies VITA 49.2 development and integration as free-and-open source (FOSS) and a wireshark plugin integrated with vrtgen.
Overview
In software development, a well-polished interface makes everyone’s job a little easier. Developers know exactly how to write their code and users know exactly what to expect when they make a function call. A well-defined communications standard is no different. All parties involved agree to communicate according to a specific model, building the foundation for interoperability. One such standard that promises interoperability is the VITA Radio Transport (VRT) standard, also known as VITA 49.
VITA 49 has undergone two major iterations to date. VITA 49.0 focused on the distribution of digitized radio frequency (RF) or intermediate frequency (IF) data along with associated metadata. Lacking in this first iteration was the command-and-control (C2) functionality necessary to provide device-level control, such as tuning commands or device discovery mechanisms. VITA 49.2 was developed to address this gap while also providing a rich framework for unambiguous association between on-the-wire metadata and data. This all sounds great – now there is a solution space for the three primary challenges associated with an open, service-oriented, RF digital architecture: device C2, management, and data distribution. So, why are there still issues with interoperability between VITA 49 compliant systems?
Despite the promise of VITA 49.2, there is a misunderstanding in the developer community about its purpose. The standard itself is not a specification that can be used to develop interoperability as discussed above, but rather it is a framework for the development of such specifications. The result of this fundamental disagreement is that it is possible for two different vendors to comply with the VITA 49 standard yet not be interoperable. In short, another standard must be built using the VITA 49 framework as its scaffolding.
The reason for this additional level of standardization is that RF data distribution and management is such a broad topic covering a diverse set of concepts of operation, that it is not feasible for all interested parties to agree on what must be part of the standard, what is optional, and what is not allowed. Geon’s aim is not to produce a new standard based on VITA 49, but to create the tooling such that any group or organization that develops a standard or “spec” for its own community can do so quickly and in a way that is easily transformed into operational code.
Workflow
The supported workflow starts with the definition of a VITA 49.2 specification in a human- and computer-readable format. This specification is then used to generate libraries in the desired language (e.g.: C++, Python, Java, VHDL). Figure 1 shows this workflow, where an agreed-upon specification is used to yield functional library code.
Figure 1 – Specification to Code
The developed libraries provide both a developer-facing API that is intuitive and simple, and a wire-facing API that conforms to the VITA 49.2 defined specification, as seen in Figure 2.
Figure 2 – Generated Library Code
Human-Readable Mapping
When developing software, what seems so easy on paper often ends up requiring way more code than preferred. When interpreting a standard, the “easy” part is writing code for a purpose that is explicitly stated within that standard. The interpretation becomes truly difficult when the program flow goes into corners not specified in the standard. The classic example of this is an error condition. While the standard may call for a particular error message to be generated, it allows the implementer to determine what error recovery looks like. It is in these logical edges that the code balloons in complexity and interoperability fails.
The specification starts simply as words in a PDF file that stakeholders have agreed should be implemented. As developers, we must make sure the transition from PDF to functioning code is as smooth and intuitive as possible. To that end, Geon has developed a plain text declarative model for our VITA 49.2 specification using YAML.
YAML allows users and developers to describe their specific packet information using a human-readable text file. The YAML file(s) are then processed by automated code generators that have a consistent behavior for all sides of each transaction in each aspect of the specification described. The generated code can be in a variety of languages, allowing developers in different domains to interact over a common data/metadata layer; the same declarative model is used to create libraries in different languages that are guaranteed to interact correctly. In other words, C++ software on a microprocessor can interact with code on an FPGA synthesized from the generated VHDL.
Effectively we have now:
- Greatly reduced implementation errors because bugs will be scoped to the automated code generators and not at and individual developer level
- Enabled the use of multiple languages
- Allowed for platform-specific performance tuning through tweaks in the generated code
- Eased the integration of future enhancements and extensions without major code refactoring by offering the developer a stable API that isolates them from details of traffic over the wire
Our Release
The release contains a YAML parser and back-end (code generators) for C++ released under the LGPL license. It also includes an example controller/controllee pair that exchange VITA 49 data, context, and control packets as well as sample YAML that define the underlying packet protocol.
In addition, the release includes a plugin for Wireshark, an open-source packet inspection tool, integrated with the vrtgen models and code generators. One of the interesting aspects of this approach is that it extends to interface with mature tooling, in this case, Wireshark. While Wireshark already has a VITA 49 plug-in, the plug-in developed with Geon’s technology provides insight into control and data packets in far more detail than that originally available.
Subsequent releases will support Python bindings and high-speed C++ bindings. Additional proprietary back-ends are also available to support specialized code generators such as VHDL. Geon would like to thank the United States Department of Defense for support in the development of this product.
If you are interested in learning more about this capability, please contact us.
