The ADEPT Framework is an industrial data and control software platform built around the concept of a “data framework” that links real-time Linux servers as a distributed resource and provides desktop client control of the time-deterministic computing and data handling capability. The ADEPT Framework is used in the largest, most demanding industrial data and control applications across the global aerospace and defense industry, but also scales down to work with low-cost computing and open source real-time Linux, including Yocto. The open architecture framework allows users to leverage best-in-class COTS and open-source technologies in a common, project-based environment.
The ADEPT Framework is comprised of four main Client tools and a real-time executive server daemon. The ADEPT Client tools include a development environment (ADEPT-DE) for configuring a system, an operator environment (ADEPT-VI) for controlling and monitoring a system, a graphical data management tool (ADEPT-GD) for data acquisition, analysis and visualization and a multi-protocol network configuration tool (ADEPT-DB) for interfacing with data signals on multiple communication buses throughout the system. The Client tools also include a fault control tool (ADEPT-FC) for managing automated fault insertion for exhaustive IO failure testing. The real-time executive daemon runs on the ADEPT real-time servers and provides the core framework services to the client tools to enable scalable management of the distributed system of real-time servers.
- Open architecture – extensibility, obsolescence avoidance, cost-minimization, and more
- Open-source – leverage and contribute to best-in-class, open-source technology
- Minimize development cycle rework – intelligent tool/domain transitions
- Rapid re-configurability – maximize support for agile development approaches throughout the framework
ADEPT Key Elements
- Layer on top of COTS and Open Hardware Projects
- Multi-core, multi-processor, multi-node distributed real-time systems
- Mixed-core processor targeting: CPU, GPU, DSP, specialty cores, etc
- High-performance distributed computation for efficient real-time system design
- Natural support for Model-Based Systems Engineering (MBSE)
- Easy access to discrete and complex IO through Logical Devices
- Data bus and serial communication rapid configuration and management
- Full Python support for automating all aspects of system setup, operation and analysis
The rtx daemon – Linux Real-Time Executive
The “rtx daemon” is a set of Linux services which runs on ARM and Intel-based computers and transforms them into full–featured real-time computers that are internally instrumented with performance, latency, jitter, and other precision time-based measurements for all aspects of the computer architecture. The rtx daemon (rtxd) software was developed, refined, and optimized by ADI over three decades and is now managed by the rtxd project. The goal of the rtxd project is to simplify the development and management of time-deterministic programming.
By installing rtxd on your real-time Linux servers you get, right out of the box, a set of optimized real-time services with a multi-processor, multi-server distributed real-time computing and data handling architecture within a scalable client-server paradigm. The rtxd dramatically reduces the engineering and IT costs of modernizing your computing and data handling assets.
- Support for a variety of model types or mixed languages, including Simulink, C/C++, Fortran, and ADSIM
- Project assembly concept for ease of switching targets and sharing hardware setups across systems
- Data dictionary for models are used for runtime control and connections
- Integrated logical device drivers for all IO provided including built-in calibration (C source provided)
- Point and click interface between models and IO interface
- Automated build for target through GUI using Make facility
- Autoconnect feature to connect model IO to IO modules based on like-names/types
- IO configuration (including device parameters, setup files, and device port names) is saved as part of a project assembly and can easily be shared between open-loop and closed-loop projects
- Auto-generation of open-loop operation based on IO in project assembly
- Connections and data dictionaries can be imported from csv files
- Open interface to add IO drivers as desired
- Configurable options for compilers
- Project startup options
ADEPT-DE Development Activities
- Selecting a real-time simulation target
- Selecting and configuring IO
- Adding models
- Adding user interface panels
- Connecting all the pieces
- Building for the target
ADEPT-DE includes the ability to effortlessly insert one or more Simulink models into a project. The ADEPT Simulink Toolbox supports the use of RTW and Embedded Coder. In addition, the Simulink models can be quickly integrated with models from other tools and hand written code, saving time and effort. The ADEPT-DE build process automatically creates an editable data dictionary, allowing the model to be examined at runtime. ADEPT-DE also designates which of the items in the data dictionary can be model inputs and model outputs. This information is available to determine IO connectivity and model-to-model connections. Simulink models are easily assigned to a processor core in a multi-core system.
The ADEPT Simulink Toolbox supports all of the capabilities of ADEPT-DE and ADEPT-VI (Data Dictionaries, DAS, ADEPT-GD, panels, etc). This allows the use of Simulink as a part of any Framework development process.
ADEPT-DE includes a special build mode for Simulink models executing in real-time on the rtX target, called Hyperfast. Hyperfast builds the Simulink model for extra lean, ultra-high-speed, real-time execution. Hyperfast algorithms are classified as those with rates of 10 kHz or greater.
Hyperfast is supported with an rtX based on a multi-core PC. One or more cores can be designated to execute hyperfast thread(s). These core(s) each run a single high-rate thread. Hyperfast cores run with interrupts disabled allowing the hyperfast thread to use 100% of the realtime of that core. This means that overhead in a Hyperfast thread is almost completely eliminated.
IO interfacing for updating and sampling is done from a Hyperfast IO library of S-function blocks. Only the opening, initializing and closing of the IO is implemented with the ADEPT IO structure.
Many of ADI’s hardware devices can be executed from a Hyperfast thread. The General Standards PCI-12AISS8AO4 and PCI66-16AISS8AO4 have APIs that specifically support Hyperfast simulation to provide very high speed, closed loop, analog control.
ADEPT-VI provides a feature-rich, easy-to-use interactive environment that allows a user to connect to, manage and monitor ADEPT-based systems. The ADEPT Framework operates with a Client/Server architecture that enables a Client PC to connect to an ADEPT-enabled Server across standard TCP/IP Ethernet. Once a Server is added to an ADEPT Framework, the Client is able to easily configure all IO, download and control new models and algorithms, and inspect all aspects of the Server’s real-time performance.
- Real-time model execution and control (transparency to target system)
- Data access to simulation and IO variables through data dictionary browser
- Command line as interactive “script” interface
- Data capture (recording) and display
- Runtime tabular display of data being captured
- Real-time test script choreographer (test schedules)
- Software-controlled or script-controlled fault insertion
- Script support including Python and Visual Basic
- Ability to set IRIG-B as system simulation timer
Like the development environment, the runtime environment is open. Python script interfaces allow automation and customization of all aspects of the tool. A COM automation interface in the Windows environment also provides easy interfacing with applications such as Excel, MATLAB, LabVIEW, TestStand, and any other standard application using an ActiveX or COM interface.
ADEPT Embedded Panels
The ADEPT Embedded Panel Toolbox provides a graphical tool for visualizing and graphically interacting with a real-time Framework.
A running panel gives a graphical correspondence to the Framework by visualizing Data Dictionary item values with the ability to update those values during run time. With indicators such as gauges, dials, and scales, you can see the value of a Framework variable in many different ways. Using controls such as knobs, sliders, and buttons, you can interact with a running Framework in a realistic manner.
The panel editor allows you to build a customized interface for configuring the display properties and layout of indicators and controls, creating a simulation interface with realistic behavior. More than 20 types of extensively configurable dynamic controls are available.
Data recording from a Model Assembly is set up through the ADEPT-VI runtime environment. Data capture lists can be set up prior to the run or set dynamically while the Framework is running.
Simple setup is achieved through drag and drop from the Data Dictionary to the data capture window. Capture lists can be saved as part of project setup or variables can be flagged in Data Dictionary for automatic capture. Data is captured on the real-time system based on the data rate specified. Each frame of data recorded is time-tagged with the system time (system time can be set to IRIG-B time). All recorded data files include a header consisting of the time/date, project name, and comments (settable through scripts or interactively).
Data recording can be set up to be collected for the entire run. Data are buffered on the real-time system and sent back to the Client PC. Data are saved in an XDR format. A utility is provided to convert XDR to MATLAB, ASCII or CSV format for further analysis.
ADEPT-VI includes full-featured test scripting through Python. Scripting supports functions such as:
- Control of the simulation
- Access to variables in the data dictionary
- Plotting functions
- Loading of real-time scripts
- Data capture setup
- Fault insertion control
In addition to real-time Schedules, ADEPT-VI also supports Triggers. Triggers are evaluated on the real-time system and can therefore be very deterministic. Schedules can be invoked based on a Trigger. Triggers can be based on functions of Data Dictionary items, set interactively or from test scripts. Data acquisition can also be Triggered on/off.
ADEPT-GD has a Client/Server interface to the Data Acquisition System (DAS). ADEPT-GD can be running on any PC on the network and connect to the data stream given the right permissions.
ADEPT-GD provides high-speed plotting of results as they come across the network from the Framework. Any or all of the four data streams can be sent to ADEPT-GD. Data to be plotted can be changed while the simulation is running. ADEPT-GD supports stripchart and X-Y plotting. A variety of line styles, colors, legends, etc are available. ADEPT-GD also supports Python scripting for additional flexibility and functionality.
In ADEPT-GD, data analysis is handled post-run via Python scripts, so virtually any analysis or visualization function that has a Python library can be implemented in a script in ADEPT-GD. Data analysis scripts can be called automatically at the end of a run (e.g. to process data that have just been collected) or they can be invoked manually (e.g. to process data that have been saved from a prior run). Due to potential performance issues that could arise from conducting analyses while receiving live streams of data, the ADEPT-GD analysis functionality is limited to post-run static data sets.
Whether it is an aircraft, a naval ship, a spacecraft, a satellite system, a military ground vehicle, or a Smart Grid, systems are increasingly “networked”. Network communication technology, including Ethernet, CAN bus, RS232/4xx serial, reflective memory, good-old ARINC 429 and more, allow subsystems within a larger system to share sensor and state information. Managing the configuration of network interfaces that provide the subsystem-to-subsystem communication within the greater system becomes more challenging as more network types and more communication channels are added to support increasing system complexity.
Sharing Networked System Configurations
In a large, networked system there are numerous subsystem suppliers developing components of the system. Each of these components or subsystems must communicate with other subsystems, developed by other suppliers, across shared network communication resources. As the design of each subsystem evolves, each supplier must be made aware of the evolving network configuration. How is data packed into messages? What is the frequency of transmission? And so on. ADEPT-DB makes it easy to share all of these details with the team and other system suppliers. ADEPT-DB’s human-readable XML database file format allows team members and suppliers to access network configuration parameters without need for special software.
As always with the ADEPT Framework, ADEPT-DB is built on a foundation of Python scripting with a full featured Python API, an integrated Python scripting editor, and a good-old-fashioned command line. Python scripting is the perfect approach for running automated checks and analysis on your networked system configurations, and generating evidence to support system certification.