Extended Fixed Wing Pilot Controller

This subclass of DtFixedWingPilotController will fly away from a radar installation if signalled to do do by the DtSimpleRadarWarningReceiver.

---

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,”, the following member functions must be implemented for the component to function correctly within the component architecture:

• A constructor of the form:

  DtFixedWingPilotController(const DtString & name,
        DtVrfObject* owner,
        DtSimManager* simManager,
        DtComponentDescriptor* desc=0,
        DtReaderWriterRegistry* parentRegistry = 0);
  

• 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. 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 parameters database. Similarly, in the sensor controller, we override createPorts() 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 parameters database entry.

  ;;
  ;; Entry for US generic attack/strike fixed wing platform
  ;;
  (US-attack-strike-fixed-wing-platform
     (parameter-type "fixed-wing-entity-param")
     (object-type 1 (1 2 225 2 -1 -1 -1))
     . . .
     (sensors
        . . .
        (simple-radar-warning-rx
           . . .
        )
     )
     (controllers
        . . .
        (simple-radar-warning-reaction-controller
           . . .
        )
     )
     (connections
        . . .
       ;;
       ;; connect <component-name>:<port-name> <component-name>:<port-name>
       ;;
       (connect simple-radar-warning-rx:emitter-list
             simple-radar-warning-reaction-controller:emitter-list)
    )
  )
  

  To implement the reactive behavior in DtSimpleRadarWarningResponse, we override the tick() function to perform the following:
  
• 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.

if(!safeControlPoint)
{
   DtWarn("DtSimpleRadarWarningResponse::tick() :
       Invalid safe control " "point %s",
       mySafeControlPointName.string());
   return;
}
DtVector safeLocation = safeControlPoint->vrfState()->vrfKinematicState()->localPosition();

• 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.

if (myFixedWingControlPortGroup->attemptToActivate())
{
   if (inVicinity(safeLocation))
   {
      DtInfo("DtSimpleRadarWarningResponse::tick(): we're done! "
             "Resume normal activity”);
      myReactingToWarning = false;
      myFixedWingControlPortGroup->deactivate();
   }
   else
   {
      flyTo(safeLocation, myFixedWingEntityState->orderedSpeed());
   }
}

• 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.

const DtList* emitterList = myEmitterListPort->value();
if (!(emitterList->first() && emitterList->first()->data()))
{
   myEmitterListPort->dataReceived();
   return;
}
DtEntityIdentifier * id = (DtEntityIdentifier *)emitterList->first()->data();
DtVrfObject* emitterSystemHost = mySimManager->vrfObjectManager()->lookupVrfObject(*id);
if (!emitterSystemHost)
{
   myEmitterListPort->dataReceived();
   return;
}
myReactingToWarning = true;
DtInfo("Simple radar warning rx detected emitter %s”, id->string());
DtInfo("Move away from the source!”);
if (myFixedWingControlPortGroup->attemptToActivate())
{
   flyTo(safeLocation, myFixedWingEntityState->orderedSpeed());
}
myEmitterListPort->dataReceived();

To get your new sensor and controller components into VR-Forces you must register the creators with the component factory. See “Adding the Actuator Component to the Component Factory,” in VR-Forces Developer’s Guide for details. You do this in plugin.cxx:

app->cgf()->factoryManager()->componentFactory()->addCreatorFcn("simple-radar-warning-receiver",
          DtSimpleRadarWarningReceiver::creator);
app->cgf()->factoryManager()->componentFactory()->addCreatorFcn("simple-radar-warning-response",
     DtSimpleRadarWarningResponse::creator);
app->cgf()->factoryManager()->componentFactory()->addCreatorFcn("scanning-radar", DtScanningRadar::creator);

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. In our new sensor and controller classes we did not add any new parameters, so we use the existing parameter and component descriptor classes associated with each component. (For an example of adding new parameters see “Creating a New Controller,” in the VR-Forces Developer’s Guide.)
In this example, we extended the CIS generic attack/strike fixed-wing entity entity 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")
   (object-type 1 (1 2 222 2 -1 -1 -1))
   (sensors
      . . .
      (simple-radar-warning-rx
         ;; We don't have any special parameters - the base class component
         ;; descriptor will suffice
         (component-descriptor-type "component-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")
      )
   )
   (controllers
      . . .
      ;;
      ;; Add our new controller component
      ;;
      (simple-radar-warning-reaction-controller
         (component-descriptor-type "fixed-wing-pilot-controller-descriptor")
         (component-type "simple-radar-warning-response")
         ;; These are additional parameters for the descriptor class we're
         ;; using (DtFixedWingPilotControllerDescriptor).
         (max-turning-Gs 9.)
         (max-turnrate-cutoff-angle 0.5236) ;; 30. degrees
      )
   )
   (actuators
      . . .
   ) ;; end actuators
   (connections
      . . .
      ;;
      ;; Connect the sensor to the new controller
      ;;
      (connect simple-radar-warning-rx:emitter-list simple-radar-warning-reaction-controller:emitter-list)
      ;;
      ;; Connect the new controller to the fixed wing actuator
      ;;
      . . .
   ) ;; end connections
) ;; end US-attack-strike-fixed-wing-entity

A modified object parameters database (configured with the new components) is in ./examples/radarWarnRx/scenario/RadarWarnRx.opd.

---

Header file:

/*******************************************************************************
** Copyright (c) 2003 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: simpleRdrWrnResp.h,v $ $Revision: 1.7 $ $State: Exp $
*******************************************************************************/

#ifndef DtSimpleRadarWarningResponse_H_
#define DtSimpleRadarWarningResponse_H_

#include "vrfmodel/fixedWingPilotController.h"

//class DtSimpleRadarWarningResponse:
//
//Instances of DtSimpleRadarWarningResponse are an example of a controller
//that implements a reactive behavior when a it receives sensor input that
//a radar has been detected.  It receives a list of emitter systems (hostile
//radar systems).  It takes the first emitter in the list and flys away to
//a location in the opposite direction.

class DtVrfObject;
class DtEntityListInputPort;   

class DtSimpleRadarWarningResponse : public DtFixedWingPilotController
{
public:
   
   //constructor
   DtSimpleRadarWarningResponse(const DtString& name, DtVrfObject* owner,
      DtSimManager* simManager, DtComponentDescriptor* desc = NULL,
      DtReaderWriterRegistry* const parentRegistry = 0);


   //destructor
   virtual ~DtSimpleRadarWarningResponse();

   //This returns a string that uniquely identifies this type of component.
   //(must be unique with respect to the component types defined in compTypes.h
   //as well as any additional user-defined components).  Returns the string
   //"simple-radar-warning-response".
   virtual DtString type() const;

   //Calculate new control values.
   virtual void tick();

   //Returns a newly created instance of this class.  We need to provide
   //this function so that we can register this class with the component
   //factory.
   static DtSimComponent* creator(const DtString& name, DtVrfObject* owner,
      DtSimManager* simManager, DtComponentDescriptor* desc,
      DtReaderWriterRegistry* parentRegistry);

protected:

   //Called by DtSimComponent::init to create myEntityListPort used to manage
   //multiple sensors that might provide targets to this controller.
   virtual bool createPorts();

   //Looks up safe control point by name.  If the object exists and it has
   //a valid state repository, returns the object.  Otherwise returns NULL.
   virtual DtVrfObject* getControlPoint(const DtString& name);

   //Returns true if we are in the vicinity of the given position.  To be
   //in the vicinity of the position means that we are within 5 seconds of
   //the given location, given our ordered speed.
   virtual bool inVicinity(const DtVector& localPosition);

protected:

   //default constructor
   DtSimpleRadarWarningResponse();

   //copy constructor, not implemented
   DtSimpleRadarWarningResponse(const DtSimpleRadarWarningResponse& orig);

   //assignment operator, not implemented
   DtSimpleRadarWarningResponse& operator=(const DtSimpleRadarWarningResponse& orig);

protected:

   //Port though which the list of hostile emitter systems will be received.
   DtEntityListInputPort* myEmitterListPort; 
   
   //true while in state of reacting to the detection of an emitter.
   bool myReactingToWarning;

   //Name of the safe location (a control point) we can retreat to.
   DtString mySafeControlPointName;

   DtVector myLocalGoal;
};

#endif

---

Implementation:

/*******************************************************************************
** Copyright (c) 2003 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: simpleRdrWrnResp.cxx,v $ $Revision: 1.18 $ $State: Exp $
*******************************************************************************/

#include "simpleRdrWrnResp.h"
#include <vlutil/vlPrint.h>
#include "vrfcore/simManager.h"
#include "vrfcore/exerciseClock.h"
#include "vrfobjcore/fixedWingEntityStateRepository.h"
#include "vrfobjcore/entListIOPort.h"
#include "vrfobjcore/vrfObjectManager.h"
#include "vrfobjcore/vrfObject.h"
#include "vrfobjcore/vrfKinematicState.h"
#include "vrfobjcore/vrfObjectGeometry.h"
#include "vrfobjcore/fixedWingFlightPSR.h"
#include "vrfobjcore/outputPortGroup.h"

DtSimpleRadarWarningResponse::DtSimpleRadarWarningResponse(
   const DtString & name, DtVrfObject* owner, DtSimManager * simManager, 
   DtComponentDescriptor* desc, DtReaderWriterRegistry * const parentRegistry) :
   DtFixedWingPilotController(name, owner, simManager, desc, parentRegistry),
   myEmitterListPort(NULL),
   myReactingToWarning(false),
   mySafeControlPointName("Safe Haven")
{
}

DtSimpleRadarWarningResponse::~DtSimpleRadarWarningResponse()
{
   if (myEmitterListPort)
   {
      delete myEmitterListPort;
      myEmitterListPort = NULL;
   }
}

DtString DtSimpleRadarWarningResponse::type() const
{
   return DtString("simple-radar-warning-response");
}

bool DtSimpleRadarWarningResponse::createPorts()
{
   if (!(myEmitterListPort = new DtEntityListInputPort("emitter-list")))
   {
      return false;
   }

   addInputPort(myEmitterListPort);

   return DtFixedWingPilotController::createPorts();
}

void DtSimpleRadarWarningResponse::tick()
{
   DtFixedWingPilotController::tick();

   //If dT is > 0 (we're not paused), then do the work
   if (dT() > 0.) 
   {
      //Called each frame by the deriving controllers to set up need variables,
      //such as myNormalBodyVelocity and myLocalAngularVelocity.
      initializeControllerForTick();

      DtVrfObject* safeControlPoint = getControlPoint(mySafeControlPointName);
      
      if (!safeControlPoint)
      {
         DtWarn("DtSimpleRadarWarningResponse::tick() : Invalid safe control "
            "point %s\n", mySafeControlPointName.string());

         return;
      }

      DtVector safeLocation = safeControlPoint->vrfState()->
         vrfKinematicState()->localPosition();

      //If I'm already reacting to a previous radar warning
      if (myReactingToWarning)
      {

         //Take control of the port group - this gives us exclusive control
         //over the fixed-wing actuator until we give that control up or a 
         //higher priority controller overrides us
         if (myFixedWingControlPortGroup->attemptToActivate())
         {
            if (inVicinity(safeLocation))
            {
               //We're done

               objectConsoleWarn() << "radarWarnRx Example - " << 
                  "We have reached the safe location!  " << std::endl;
               objectConsoleWarn() << "radarWarnRx Example - " << 
                  "Resume normal activity." << std::endl;

               myReactingToWarning = false;

               //Give up control of actuator's port group so other 
               //components may control it. 
               myFixedWingControlPortGroup->deactivate();
            }
            else
            {
               //Move toward the safe location
               flyTo(safeLocation, myFixedWingEntityState->orderedSpeed());
            }
         }
      }
      else
      {
         if (! myEmitterListPort || ! myEmitterListPort->activeConnection() ||
            !myEmitterListPort->value())
         {
            objectConsoleVerbose() << "radarWarnRx Example - " << 
            "No emitter list for radar warning reaction controller" <<
            std::endl;

            return;
         }

         //Get 1st emitter system on list of emitters on the port 
         const DtEntityTargetList* emitterList = myEmitterListPort->value();
      
         //If there aren't any emitters out there, there's nothing to react to
         if (!(emitterList->first() && emitterList->first()->data()))
         {
            //Mark the data as "old"
            myEmitterListPort->dataReceived();

            return;
         }

         //We have an emitter out there
         DtEntityTargetInformation * info = 
            (DtEntityTargetInformation *)emitterList->first()->data();

         //Look up the entity with the radar
         DtVrfObject* emitterSystemHost = 
            mySimManager->vrfObjectManager()->lookupVrfObject(info->id());

         if (!emitterSystemHost)
         {
            //Mark the data as "old"
            myEmitterListPort->dataReceived();

            return;
         }

         //We're now reacting to an emitter
         myReactingToWarning = true;

         objectConsoleWarn() << "radarWarnRx Example - " << 
         "Simple radar warning rx detected emitter " << info->id().string() <<
         "." << std::endl;
         objectConsoleWarn() << "radarWarnRx Example - " << 
         "Move away from the source!" << std::endl;

         //Take control of port group - this gives us exclusive control
         //over the fixed-wing actuator for the duration of the frame (no other
         //controllers that come after this one will be able to control it).
         if (myFixedWingControlPortGroup->attemptToActivate())
         {
            //Move toward the safe location
            flyTo(safeLocation, myFixedWingEntityState->orderedSpeed());
         }
      
         //Mark the data as "old"
         myEmitterListPort->dataReceived();
      }
   }
}

DtSimComponent * DtSimpleRadarWarningResponse::creator(const DtString & name, 
   DtVrfObject* owner, DtSimManager * simManager, DtComponentDescriptor* desc,
   DtReaderWriterRegistry * parentRegistry)
{
   return new DtSimpleRadarWarningResponse(name, owner, simManager, desc, 
      parentRegistry);
}

DtVrfObject* DtSimpleRadarWarningResponse::getControlPoint(const DtString& name)
{
   DtVrfObject* controlPoint = mySimManager->vrfObjectManager()->
      lookupVrfObjectByName(mySafeControlPointName);
   
   if (!controlPoint)
   {
      objectConsoleWarn() << "radarWarnRx Example - " << 
      "DtSimpleRadarWarningResponse::getControlPoint() : Can't find control point " <<
      name << std::endl;
      return NULL;
   }
   
   if (!controlPoint->vrfState())
   {
      objectConsoleWarn() << "radarWarnRx Example - " << 
         "Control point " << name << " does not have state repository!" << std::endl;
      return NULL;
   }

   return controlPoint;
}

bool DtSimpleRadarWarningResponse::inVicinity(
   const DtVector& localPosition)
{
   DtLocalVector location = myFixedWingEntityState->localPosition();

   myProcessState->setDistanceSquared(location.distSquaredTo2D(localPosition));
   
   if (myProcessState->lastDistanceSquared() == 0.0)
   {
	   myProcessState->setLastDistanceSquared(myProcessState->distanceSquared());
   }

   if (myProcessState->distanceSquared() < (myFixedWingEntityState->orderedSpeed() * 
      myFixedWingEntityState->orderedSpeed() * 25.0)) //5 seconds away...
   {
      return true;
   }

   return false;
}