Reusable Real-Time Process Architecture for Missile Avionics
The figure below is an example of a reusable software architecture captured
in a
real-time process architecture style
.
This reusable architecture is being developed for missile guidance and control
applications by personnel at the Army Missile Command (MICOM) Software
Engineering Directorate. The style used for this architecture is that provided
by the
MetaH architecture specification language
.
This style supports hierarchical decomposition (the concurrent activities
represented by the captain, pilot, etc. actually contain multiple real-time
processes within them). It also supports both real-time message passing (e.g.
missile_state and missile_position updates) and shared data access that is
synchronized using a real-time semaphore protocol (e.g. battle_map_mode,
pilot_mode).
Captain
The captain object is analogous to the captain of a ship. The captian executes
the mission flight logic of the missile and is responsible for decision making that
occurs in the onboard system at the mission level. A mission level decision is
defined as a decision that alters the way the mission is carried out, or affects the
end result of the mission, and is based on external information (be it uplinked
information or information provided by onboard sensors).
An example of a mission level decision would be deleting the current waypoints
and replacing them with an alternate set. This affects the missile's course,
which alters the way the mission is carried out. Another example of a mission
level decision would be the designation of a new primary target. This would
alter the end result of the mission by engaging a different target.
The nominal execution of the missile's flight logic is not normally considered
decision making, since that typically consists of a predefined sequence of
events. However, decision making can be included in flight logic, when the
action to be taken is dependent on information from an external source.
Pilot
The pilot is responsible for guiding and controlling the missile. The pilot
has a set of guidance modes which can be invoked in order to perform the
different types of guidance. These modes may or may not have parameter data
associated with them. Each pilot, when instantiated, contains the modes
required by the missile to perform its mission. The pilot has external
interfaces to control devices of the missile.
The missile_state, object_state and actuator_command values are time-varying
signals that reflect the continuous time-varying state of real-world objects
and are implemented as periodic data samples sent using a real-time message
passing protocol. The piloting mode and the selection of objects of interest
occur rarely and at irregular intervals, and so are implemented as calls to
subprograms declared in monitor pilot_mode.
Some of the piloting modes require knowledge of the missile state relative to
another object, such as a waypoint or target. Calls are made to subprograms
in the battle_map_mode monitor to select these objects as required by the
current guidance state of the missile and the current piloting mode.
Battle Map
The battle map maintains the missile's view of waypoints, the earth, and the
target(s). The battle map also provides a generic set of operations to
express relationships among these entities and the missile with regard to
position, velocity, time, line of sight, line of sight rate, and angular
relationships.
In this architecture, the overall operation of the battle map is that it
provides time-varying signals that give the state of the missile relative to
some fixed navigation coordinate system and also relative to some selected
object(s). The time-varying signals are provided as periodic data samples
sent using a real-time message passing protocol. The selection of the objects
of interest, which occurs sporadically and occasionally, is made by calling
subprograms declared in the battle_map_mode monitor. This monitor also
provides subprograms that allow components such as the captain to define the
characteristics of target and waypoint objects.