F18 Example

The f18 program simulates a simple HLA or DIS vehicle.

By default, that vehicle is n F/A18 flying in a circle, just off the coast of California, USA, but you can control the entity type, location and route.

The f18 generates predictable HLA entity update messages (or DIS entity state PDUs), so it is a useful tool for debugging applications that receive and interpret these messages. It can also fire munitions and react to detonations.

---

The F18 is composed of two major classes:

• DtF18Initializer
• DtVehicleSim

The F18 example is contained in several major files:

• The vehicle simulation class.
• The application initialization class.
• Advanced configuration for a modified FOM.

The main application:

/****************************************************************************
 * Copyright (c) 2017 VT MAK
 * All rights reserved.
 ****************************************************************************/


#include "multiVehicleFed.h"
#include "multiF18Init.h"

#include <vl/exerciseConn.h>
#include <vl/entityPublisher.h>
#include <vl/reflectedEntityList.h>

#include <vlutil/vlProcessControl.h>
#include <vlutil/vlRtiMismatchException.h>
#include <vlutil/vlMiniDumper.h>

#include <matrix/geodeticCoord.h>

#include <stdlib.h>
#include <iostream>

#ifndef _WIN32
#include <sys/socket.h>
#endif

// *****************************************************************
// *************************** GLOBALS *****************************
// *****************************************************************
DtTime timeOutInterval        = 12.0;              // seconds
DtTime timeThreshold          =  5.0;              // seconds
double translationThreshold   = 1.0;               // meters
double rotationThreshold      = DtDeg2Rad( 3.0 );  // radians

// Static functions
static int keybrdTick( );

#if VXWORKS
#define main realMain
DT_VXWORKS_APP(f18)
#endif

// *****************************************************************
// ***************************  MAIN *******************************
// *****************************************************************
int main( int argc, char* argv[] )
{
   // Used for error handling
   DtINIT_MINIDUMPER( "Parallel-F18" );

   try
   {
      // get the PID so we can run multiple F18's
      int pid = DtGetPid();
      DtString pidStr( pid );

      // get the Application name
      DtString appName = "VR-Link F18 " + pidStr;
      DtF18Initializer initializer( argc, argv, appName );

#if DtDIS
      // Set the default DIS version
      initializer.setDisVersionToSend( 7 );
#else
      // Set the default FED File, executable, and version
      initializer.setFedFileName( DtDefaultRpr2Fom );
      initializer.setExecName( "MAK-RPR-2.0" );
      initializer.setRprFomVersion( 2.0 );
      initializer.setRprFomRevision( 1 );
#ifdef DtHLA_1516_EVOLVED
      initializer.addFomModule("MAK-VRLExt-1_evolved.xml");
#endif
#endif

      initializer.parseCmdLine();

      initializer.setApplicationNumber( pid );
      DtString defaultF18Name( initializer.f18Name() );
      defaultF18Name += " " + pidStr;
      initializer.setF18Name( defaultF18Name );
#ifdef DtHLA
      initializer.setFederateType( "Parallel F18" );
      initializer.setFederateName(defaultF18Name);
#endif


      // Create an instance of our simulator
      DtMultiVehicleFed simulator;

      // Set up default static values
      DtEntityPublisher::setDfltRotationThreshold( rotationThreshold );
      DtEntityPublisher::setDfltTranslationThreshold( translationThreshold );

      // This is the only DIS specific code in this file.
#if DtDIS
      DtEntityPublisher::setDfltTimeThreshold( timeThreshold );

      // MUST use async I/O in parallel mode for thread saftey
      // Sync I/O in DIS not yet thread safe
      initializer.setUseAsynchIO(true);
#endif

      // Connect to the exercise or RTI
      simulator.initializeExConn(DtTime(timeThreshold), &initializer);
      DtExerciseConn* exConn = simulator.exerciseConn();
      DtClock* clock = exConn->clock();

#ifdef DtHLA
      // Let other VR-Link federates know that we are initializing
      // Helps control request update calls when creating many entities
      // Requests are delayed until all federates are initialized or executing
      std::cout << "[" << clock->elapsedRealTime() << ", 0] Initializing" << std::endl;
      exConn->setExecutionStatus(vrlstatus_initializing);
      simulator.drainInput(0.1);
#endif

      DtTime frameTime = initializer.deltaTime();

      // initialize the fleet
      DtVehicleSim::setSimDeltaTime(frameTime);
      simulator.initializeFleet(0, initializer.count(), &initializer);
      simulator.drainInput(frameTime);
      simulator.publish();

#ifdef DtHLA
      // Let other VR-Link federates know that we are initialized
      exConn->setExecutionStatus(vrlstatus_initialized);
      simulator.drainInput(0.1);
      std::cout << "[" << clock->elapsedRealTime() << ", 0] Initialized" << std::endl;

#endif

      // Simulation loop
      int forever = 1;
      DtTime dt = frameTime;
      DtTime outputTime = 0.0;
      double outputInterval = initializer.outputInterval();

#ifdef DtHLA
      // Let other VR-Link federates know that we are executing
      std::cout << "[" << clock->elapsedRealTime() << ", 0] Executing" << std::endl;
      exConn->setExecutionStatus(vrlstatus_executing);
      simulator.drainInput(0.1);
#endif

      // Reset elapsed time to 0 to match initial simulation time
      clock->init();

      unsigned long frameCount = 1;
      double totalDrainDuration = 0.0;
      double totalSimDuration = 0.0;
      double totalPubDuration = 0.0;
      double totalIdle = 0.0;
      double totalFrameDuration = 0.0;
      int numberFrameOverflows = 0;
      double totalOverflow = 0.0;
      DtTime lastTime = clock->absRealTime();
      std::cout << std::fixed;
      while( forever ) // to keep cfront quiet
      {
         DtTime idle = 0.0;
         DtTime startTime = clock->absRealTime();
         dt = startTime - lastTime;

         simulator.setSimTime(clock->elapsedRealTime());

         // process incoming data
         DtTime before = clock->absRealTime();
         simulator.drainInput(frameTime);
         DtTime drainDuration = clock->absRealTime() - before;
         totalDrainDuration += drainDuration;

         if ( keybrdTick( ) == 0 )  break;

         DtVehicleSim::setSimDeltaTime(dt);

         // Perform simulation for the current time frame
         before = clock->absRealTime();
         simulator.simulate();
         DtTime simDuration = clock->absRealTime() - before;
         totalSimDuration += simDuration;

         // Publish simulation changes
         before = clock->absRealTime();
         simulator.publish();
         DtTime pubDuration = clock->absRealTime() - before;
         totalPubDuration += pubDuration;

         //frameDuration = drainDuration + simDuration + pubDuration;
         DtTime frameDuration = clock->absRealTime() - startTime;
         totalFrameDuration += frameDuration;
         if (frameDuration < frameTime)
         {
            idle = frameTime - frameDuration;
            totalIdle += idle;
            dt = frameTime;
         }
         else
         {
            dt = frameDuration;
            idle = -1.0;
            numberFrameOverflows++;
            totalOverflow += frameDuration - frameTime;
         }

         if (outputInterval <= 0.0 || outputTime < startTime)
         {
            outputTime = clock->absRealTime() + outputInterval;
            std::cout << "[" << std::setprecision(2) << simulator.simTime() << ", " << frameCount << "] #entities: " << simulator.numberRemoteEntities()
               << " total=" << std::setprecision(6) << frameDuration << "(" << totalFrameDuration / frameCount << ")"
               << " idle=" << idle << "(" << totalIdle/frameCount << ")"
               << " drain=" << drainDuration << "(" << totalDrainDuration / frameCount << ")"
               << " sim=" << simDuration << "(" << totalSimDuration / frameCount << ")"
               << " pub=" << pubDuration << "(" << totalPubDuration / frameCount << ")"
               << " #FO=" << numberFrameOverflows << "(" << (numberFrameOverflows > 0 ? totalOverflow/numberFrameOverflows : 0) << ")"
               << std::endl;
            numberFrameOverflows = 0;
            totalOverflow = 0.0;
         }

         if (idle > 0.0)
         {
            // wait for real time to catch up to simulated time
            DtTime sleepTime = simulator.sleep(idle);
         }

         lastTime = startTime;
         frameCount++;
      }

      simulator.dismantleFleet();   // Dismantle the fleet of vehicles
      simulator.dismantleExConn();  // Dismantle exercise connection
   }
   DtCATCH_AND_WARN(std::cout);

   return 0;
}

int keybrdTick( )
{
   char* keyPtr = DtPollBlockingInputLine();
   if ( !keyPtr )  return 1;  // no input

   switch( *keyPtr )
   {
   case 'q':
   case 'Q':
      return 0;
   default:
      std::cout <<  "Unrecognized command key " <<  *keyPtr  << std::endl;
      break;
   }
   return 1;
}