Full-Speed Simulator Meeting

			      25 March 2015


Project Labor Budget Remaining: 64%

********Recent Progress and News:

* Rob is running wall-following sims with the new code. Speed up was  x7 on
  two different machines.

* The "interruped fuction call" error occurred again.


*******Decisions:

* Expend the effort to make the event-callback version on our branch flyable?
  Tag it and be ready for a merge?  (YES)

* If Rich is too busy, Rob or Kent to start on merging big three into GNC
  (Phase II)?

* Expend the effort to get TRN working in Phase I,  before starting Phase II? YES

* Merge Phase I before we have fast TRN?


********Next Tasks:

* Rich/Rob: Debug "interrupted function call" problem.

* Rich: Add flags -fastsim and (optional) -sim that run the simulator fast
  	and real-time, respectively.

* Rob:  Try to speed up the 7x 
  	 - Tried increasing VM RAM on sandpiper-qnx.

* Rob: (minor)
       -xFree86 on Mac?
       -Can't set PDT on sandpiper-qnx.  It keeps hanging on
       	compilations/installs on Atlas.





* Rich/Rob: (Optional for now) Create a triggered version of
  	TerrainAidDriver.  Get TRN to run in the fast simulation.

* Rich: (Phase II) Massage the big three GNC tasks into a single task that
  	runs real-time for flight, fast for simulation.

* Rob:  Download xcode and get CVS running on the Mac.  Checkout the code
  	tree.  

* Rob: 	Get the Qnx Vm to share memory with the Mac.  If this works, I can
        checkout the code tree from CVS on the Mac, then compile it with the
        Qnx vm.

* Rob:  Review the difference between the -bisim and -sim arguments.  Merge
  	them if possible.

* Rob:  Assist Rich where possible.

* Kent: (If time permits) Come up to speed on the code.  Rob will help.

* Kent: (If time permits) Run a sim.  Rob will help.

* Hans: (If time permits) Provide example code showing how to link the GNC
    	process with the simulated sensor IFs and the simulator to create a
    	single process for simulation. The GNC code is unchanged between
    	flight and simulation.

* Rob: (Skip) Merge the CVS head into the FastSim branch.  The objective is
        to keep the branch up to date so that the eventual merge back into
        the head will take minimum effort.


*******Definition of terms:

  * Phase I - Faster-than-real-time simulation that retains the current
    separate processes and is done with event-callbacks.

  * Phase II - The big three (Nav, Layered, Dynamic) are moved into a single
    process.   This process also contains the simulator during simulations.


*******Last Meeting:

Rich proposing to slow down fast sim and running TRN as fast as possible.


*******Notes:

Rich: millisleep(2) is between the end of the simulation and the time
      increment and start of Navigation.  Ticksize of 5 or 10 then sets the
      sleep time because it's greater.

To merge our branch with the head we need to:
 * Finish code that triggers Nav on real-time versus sim completion.
 * Down-merge the ongoing head development first.  
 * Review changes with Hans and make a test plan.
 * Possibly piggy back a sea-trial.

******Overall Objectives:

     1. Qnx Vm (Rob)  (DONE)
     	-Desktop
	-Laptop
     2. Synchronize Layered Control(Rich)  (DONE)
     	-Done using event call backs.
     3. Non blocking operation (Rich, Rob, Kent, Hans)
     	-First pass using event callbacks.
	-Second pass moves GNC processes into a single process.
     4. TRN Integration (Rich, Rob)
     5. Testing and Validation (Rob)

********Meeting Notes:

The group consensus was that, at least for the short term, we will continue
to debug the "interruped function call" error.  The other option is to drop
this and start trying to merge the big three + the simulator into a single
process (Phase II).

Rich pointed out that this error only appears when the code runs at full
speed.

Rich will work on the code to switch between real-time flight versus
full-speed sim.

Rob will bring Kent up to speed on compiling and running simulations on
mvc-bi. 

Rob and Kent will investigate the Qnx debugger.  We'll see if we can
replicate the error and use the debugger to obtain a stack trace.