Radar Warning (radarWarnRx)

Table of Contents

• Creating New Sensor Components
• Implementing the Radar Warning Receiver Class
• Creating the New Controller Component
• Connecting the Sensor to the Controller
• Adding the New Components to VR-Forces
• Configuring Entities to Use the New Components
• How to Run the Example
  • Usage
• Classes
• Plugin Entry Points

This example extends the CIS generic attack/strike fixed-wing entity (SU-25 1) to have a radar warning receiver.

It also adds a reactive behavior to the plane, such that when its radar warning receiver detects a radar, the entity moves to a designated safe location. The safe location is a control point positioned out of range of the radar threat. Once it has reached the safe location, it resumes the task it was executing (if any).

The radarWarnRx example demonstrates how to add a new sensor component and connect it to controller components. It adds the following new capabilities and behaviors to existing entities in VR-Forces:

• Radar warning receiver
• Radar sensor
• Reactive behavior in response to a radar threat detected by the radar warning receiver.
  

Creating New Sensor Components

VR-Forces provides a basic emitter, DtEmitterComponent (emitterComp.h), so we can derive our radar sensor from this component. Anytime you create a new component, you have to provide the following member items in your new class:

• A constructor of the same form of its DtSimComponent parent class
• A type() member function that returns a string that uniquely identifies the new class
• The string returned by the type() function is the key into the component factory that VR-Forces uses to instantiate new components. Please see compTypes.h for the set of string types for VR-Forces component classes.
• A static creator() method that returns a newly created instance of the class.

Implementing the Radar Warning Receiver Class

The radar warning receiver class, DtSimpleRadarWarningReceiver (simpleRadar- WarnRx.h), needs to detect the emissions and notify any interested controllers that it has detected one or more radars. In this example it merely checks for anything sending out emissions within a 5 Km radius. The class has a VR-Link DtReflectedEmitterSystem- List data member, myReflectedEmitterList, which it uses to gain knowledge of all entities generating emission PDUs over the network

If it finds any, it extracts the host ID of the emitter and places that host ID on an emitter list port. The radar warning receiver uses the existing DtEntityListOutputPort class to communicate the identity of the set of radars it has detected in the current tick. It will ultimately be connected to the radar warning response controller that will receive the data on the emitter list port (a list of detected radars) and use that information to drive its behavior

As a provider of data (the list of detected emitters), the DtSimpleRadarWarningReceiver has a DtEntityListPort data member, myEmitterListPort. It is responsible for creating and setting values on the port. Each tick, it does the following:

1. Calls attemptToActivate() on its emitter list output port, to check if the connection through this port group is active. This checks to see if the recipient will receive data placed on the ports in the group (this will only happen if there is no component with a higher priority currently connected).
2. Iterates through its reflected emitter list.
3. If it finds an emitter that is within 5 Km of the entity’s current location and at least one has a power greater than zero, it places it on the emitter list port.

Creating the New Controller Component

The new controller component, DtSimpleRadarWarningResponse (simpleRdrWrnResp.h), provides a simple response when it receives a warning from the radar warning receiver. It attempts to move toward a waypoint named Safe Haven, if an object by that name exists in the simulation.

The controller for handling the reaction to a threat detected by the radar warning receiver is intended for a fixed-wing entity. All of the movement-related controllers for fixed-wing aircraft are derived from DtFixedWingPilotController, so we derive from that class for our new controller. Among other things, we inherit the ports required to control a DtFixedWingActuatorComponent, the actuator used by the F-16 entity.

Like the sensor components created in “Creating the New Sensor Components,” previously in this example, the following member functions must be implemented for the component to function correctly within the component architecture:

• A constructor
• A type() function that returns a string that uniquely identifies the new class
• A static creator() function that returns a newly created instance of the class.

The string returned by the type() function is the key into the component factory that VR-Forces uses to instantiate new components. Please see compTypes.h for the set of string types for VR-Forces component classes.

Connecting the Sensor to the Controller

We need to connect the radar warning receiver sensor to the radar warning response controller. As a consumer of data, the radar warning response class has a DtEntityListInputPort member variable, myEmitterListPort, through which it receives the identity of any detected radars (generated by the radar warning receiver). We override createPorts() to instantiate the input port member and add it to our list of input ports. The name of the port, emitter-list, identifies the port when connecting components to one another in the object parameter database. Similarly, in the sensor controller, we override create- Ports() to create its output port member variable, myEmitterListPort, also with the name emitter-list. These two components are connected to one another through these ports by name, in the object parameter database entry.

To implement the reactive behavior in DtSimpleRadarWarningResponse, we override the tick() function to perform the following:

1. Check to see if we can find our safe location. The safe location is a control point named Safe Haven (mySafeControlPointName in the code). Look it up in the Object Manager.
2. If we are in the process of reacting to a previous threat, move toward our safe location. Check to see if we have arrived at our safe location. If we have, we are done and we no longer need to control the actuator. Otherwise, continue moving toward the safe location.
3. If we are not currently reacting to a detected radar, check the port to see if any have been detected and are in range. We are looking for the first emitter we find in range. If we find one, take control of the actuator’s port group and fly to a safe location.

Adding the New Components to VR-Forces

To get your new sensor and controller components into VR-Forces you must register the creators with the component factory. The function DtInitializeVrfPlugin in plugin.cxx demonstrates how to do this.

Configuring Entities to Use the New Components

Now that we have incorporated the new components into the application, we need to configure specific entities to use the new components. We also want to add a new configuration parameter to our radar warning receiver called emitter-detection-range. This indicates the range at which emitters will be detected. This is done by creating a new descriptor for the radar warning receiver. We will call this descriptor radar-warn-receiver-descriptor and add our new parameter to it.

In this example, we extended the CIS generic attack/strike fixed-wing entity (SU-25 1) with the new radar warning receiver and corresponding response controller.

;;
;; Entry for CIS generic attack/strike fixed wing platform
;;
(CIS-attack-strike-fixed-wing-platform
   (parameter-type "fixed-wing-entity-param")
   ...
   (sensors
      . . .
      (simple-radar-warning-rx
         ;; Use the new descriptor type
         (component-descriptor-type "radar-warn-receiver-descriptor")
         ;; This identifies the class type to create for this sensor. It
         ;; should match the string returned by
         ;; DtRadarWarningReceiver::type().
         (component-type "simple-radar-warning-receiver")
         (emitter-detection-range 5000.0)
         ...
      )
   )
   ...
) ;; end US-attack-strike-fixed-wing-entity

In the fixed-wing-fighter-jet.sysdef file:

(controllers
. . .
   ;;
   ;; Add our new controller component
   ;;
   (simple-radar-warning-reaction-controller
      (component-descriptor-type "fixed-wing-pilot-controllerdescriptor")
      (component-type "simple-radar-warning-response")
      (attached-to-list )
      (min-tick-period -1.000000)
      (min-tick-period-variance -1.000000)
      (process-state-repository-name "")
      (process-state-repository-type "")
      (max-turnrate-cutoff-angle 0.523600)
      ; Additional parameters for the descriptor class we're using
      ...
   )
)
(actuators
   . . .
) ;; end actuators
(connections
   . . .
   ;; Configure new controller inputs (emitter-list) to be system
   ;;inputs
   (connect system:emitter-list
      simple-radar-warning-reaction-controller:emitter-list)
   ;; Connect the new controller to the fixed wing actuator
   (connect simple-radar-warning-reaction-controller:
      fixed-wing-control flight-kinematics:fixed-wing-control)
   . . .
) ;; end connections

A modified object parameter database (configured with the new components) is in ./data/simulationModelSets/developer_toolkit_examples/radarWarnRx/vrfSim/Radar-WarnRx.opd.

Since this example is loaded as a plugin, it can be used in conjunction with the released VR-Forces application

How to Run the Example

This example demonstrates how add a new kind of behavior, detect and react to a perceived threat.

The sensors and behaviors implemented in this example are not realistic. The purpose of the example is to show how and where you would incorporate your own algorithms and models into VR-Forces.

An example scenario demonstrating the new behaviors is in ./examples/RadarWarnRx/scenario/RadarWarnRx.scn. The scenario loads an object parameters database that configures the CIS generic attack/strike fixed-wing entity with new sensor and behavior components. The example contains a single CIS generic attack/strike fixed-wing entity. The entity has a plan that contains a task to move-to waypoint Alpha. As it moves toward the waypoint, it comes within detection range of the radar. When it comes into range, it reacts by moving to a safe location (a control point named Safe Haven). Upon reaching the control point, it resumes its original task to move toward waypoint Alpha.

The Radar Warning example demonstrates the following:

• How to create a new sensor component
• How to create a new descriptor for a component
• How to implement the Radar Warning Receiver Class
• How to create a new controller component
• How to connect the sensor to the controller
• How to add the components to VR Forces
• How to configure entities to use the new controllers

When adding a new sim component that will be added as part of a new system, it is also recommended that you create a Simulation Object Editor plugin so that the SOE will know how to read and write the configuration for the new sim component. The Radar Warn Editor example is related to this example and shows to to register the new sim components with the SOE.

Usage

In the Launcher, click the Plug-ins button to bring up the Plug-ins Selection dialog. Enable the plugin.

To view the behavior:

1. Start VR-Forces GUI and SIM.
2. Load the scenario data\scenarios\developer_toolkit_examples\radarWarnRx\radarWarnRx.scn.
3. Right click > Information... on the SU-25 1 aircraft to display its information window.
4. In the information window, set the Notify Level to Info.
5. Ensure that Settings > Emitter Volumes is toggled ON.
6. Click on play button.
7. The aircraft will start moving toward 'Waypoint Alpha'.
8. Once it detects the missile launcher it will veer off toward the waypoint named 'Safe Haven'.
9. The following messages will be displayed in the Object Console window:
   • Simple radar warning rx detected emitter
   • Move away from the source
10. Upon arrival at 'Safe Haven', it will resume its original course (toward 'Waypoint Alpha').

Classes

DtSimpleRadarWarningReceiver	This subclass of DtSimComponent will check to see if there are any emitter systems in the area that could sense a fixed wing.
DtSimpleRadarWarningResponse	This subclass of DtFixedWingPilotController will fly away from a radar installation if signalled to do so by the DtSimpleRadarWarningReceiver.
DtRadarWarningReceiverDescriptor	This subclass of DtComponentDescriptor allows for the specification of new attributes for this sensor, in this case the maximum detection range of emitters.

---

Plugin Entry Points

/*******************************************************************************
** Copyright (c) 2003 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/


#include "vrfcgf/vrfPluginExtension.h"
#include "simpleRadarWarnRx.h"
#include "simpleRdrWrnResp.h"
#include "radarWarningReceiverDesc.h"

#include "vrfcgf/cgf.h"
#include "vrfcgf/factoryManager.h"

extern "C" {

   DT_VRF_DLL_PLUGIN void DtPluginInformation(DtVrfPluginInformation& info)
   {
      info.pluginName = "radarWarnRX";
      info.pluginVersion = "1.1";
      info.pluginCreator = "MAK Technologies";
      info.pluginCreatorEmail = "sales@mak.com";
      info.pluginContactWebPage = "www.mak.com";
      info.pluginContactMailingAddress = "10 Fawcett Street, Suite 204, Cambridge, MA 02138 USA";
      info.pluginContactPhone = "(617) 876 8085";
   }

   DT_VRF_DLL_PLUGIN bool DtInitializeVrfPlugin(DtCgf* cgf)
   {
      //Register the radar warning receiver sensor.  The string passed into this
      //function is the same as the string returned by DtSimpleRadarWarningReceiver's
      //type() function.
      cgf->factoryManager()->componentFactory()->addCreatorFcn(
         "simple-radar-warning-receiver", DtSimpleRadarWarningReceiver::creator);  

      //Register the radar warning reaction controller.  The string passed into this
      //function is the same as the string returned by DtSimpleRadarWarningResponse's
      //type() function.
      cgf->factoryManager()->componentFactory()->addCreatorFcn(
         "simple-radar-warning-response", DtSimpleRadarWarningResponse::creator);  

      //Register teh descriptor with the descriptor factory.
      cgf->factoryManager()->componentDescriptorFactory()->addCreatorFcn(
         DtRadarWarningReceiverDescriptorType, DtRadarWarningReceiverDescriptor::creator);
      
      return true;
   }
}