Next: 5 Building the Application Specific Interface
Up: Appnotes Index
Previous:3 What is a Command Program
Figure 4 - 1, Layered Command
Program Architecture, reflects the bridging role between the CCS and the SPS played by the command program. The bottom two layers address the Signal
Processing Program perspective while the top two layers address the CCS perspective. The bottom most layer is the Command Program Interface (CPI) layer
and consists of the generic set of graph control functions provided by the Signal Processing Application autocoding tool. This layer can be viewed as
Commercial of the Shelf (COTS) software from the perspective of the CP. The next layer is the Application Specific Interface (ASI) layer. This layer provides a
set of application specific low level control functions. For example, where the CPI level might provide a generic "appParamWrite" function, the ASI might
provide an application specific "writeMySpecificParam" function for each CP visible parameter in the application. This layer is discussed at length in Section
5.0, Building the Application Specific Interface.
Command programs are highly state oriented programs since they control and reflect the state of the signal processing application. For example, an airborne
radar application CP may include an airborne target search mode and an airborne target track mode. The Executive Finite State Machine (EFSM) layer captures
the CP state functionality and manages transitions between states. As discussed in Section 6.0, Autocoding Tool Evaluations, commercially available
autocoding tools may be used to construct this layer of the CP. The final layer is the User Interface layer. It manages communication with the remainder of the
Command and Control System. For some applications this layer may consist of the Graphical User Interface (GUI) code. The RASSP command program
autocoding project did not address this layer. The layered nature of this architecture is illustrated in 4 - 2 through Figure 4 - 4.
A User Interface (UI) layer function that reads a state command from the user is illustrated in Figure 4 - 2, User Interface Layer Calls Executive State Machine
Layer. The command is passed to an Update State routine that resides in the EFSM layer.
 
 
This EFSM layer routine, shown in Figure 4 - 3, Executive State Machine Layer Calls Application Specific Interface Layer, validates the legality of the state transition requested and then invokes a sequence of ASI layer functions to accomplish the request.
The ASI layer routine invoked is shown in Figure 4 - 4, Application Specific Interface Layer Calls Command Program
Interface Layer, and is called EnterModeB. This is the routine that directly manages the graph. It invokes a collection of
CPI layer calls to obtain handles for the new graph, initialize the hardware, load the graph etc.
The complexity of the various CP layers will vary with the application. For some simple CPs the Electronic Finite State Machine layer might be absorbed into the Application Specific Interface (ASI) layer and/or the User Interface (UI)
layer. In a multi-mode radar application, the ESM layer will be extensive since the Command and Control System will
need to sequence the Signal Processing System through multiple, possibly concurrent or nested states. If a collection of
graphs presents a complex interface to the CP with many graph parameters and dynamic queues, the ASI interface layer
will be extensive.
4.0 Top Level Command Program Architecture
UI.getUerInput() {
      StateCmd = ReadStdIn() ;
      ESM.updateState(state_cmd) ;
ESM.updataState(state_cmd) {
switch ( mode_state ) {
      case: modeA
      switch ( submode_state ) {
          case: submode1
          switch ( state_cmd ) {
               case: go_to_modeB
               ASI.Pause () ;
               ASI.reParam1 (outdata ) ;
               ASI.KillModeA() ;
               ASI.EnterModeB() ;
 
ASI.EnterModeB() {
      apModeBHdl = AII.appRead("ModeB.Graph.Name")
      CPI.initLaunchPackage (apModeBHdl) ;
      CPI.initEmbSolaris() ;
      CPI.appLoad(apModeBHdl) ;
      CPI.appReset(apModeBHdl) ;
      ApParam1Hdl = CPI.appGetParam (apModeBHdl, "Graph.Name.of.Param1") ;
 
Next: 5 Building the Application Specific Interface
Up: Appnotes Index
Previous:3 What is a Command Program