src/Instrumentation/rnav_waypt_controller.cxx

   1 // rnav_waypt_controller.cxx - Waypoint-specific behaviours for RNAV systems
   2 // Written by James Turner, started 2009.
   3 //
   4 // Copyright (C) 2009  Curtis L. Olson
   5 //
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License as
   8 // published by the Free Software Foundation; either version 2 of the
   9 // License, or (at your option) any later version.
  10 //
  11 // This program is distributed in the hope that it will be useful, but
  12 // WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software
  18 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19
  20 #include "rnav_waypt_controller.hxx"
  21
  22 #include <cassert>
  23
  24 #include <simgear/sg_inlines.h>
  25 #include <simgear/structure/exception.hxx>
  26
  27 #include <Airports/runways.hxx>
  28
  29 namespace flightgear
  30 {
  31
  32 const double KNOTS_TO_METRES_PER_SECOND = SG_NM_TO_METER / 3600.0;
  33
  34 double pmod(double x, double y)
  35 {
  36   if (x < 0.0) {
  37     return -fmod(x, y);
  38   } else {
  39     return fmod(x,y);
  40   }
  41 }
  42
  43 // implementation of
  44 // http://williams.best.vwh.net/avform.htm#Intersection
  45 bool geocRadialIntersection(const SGGeoc& a, double r1, const SGGeoc& b, double r2, SGGeoc& result)
  46 {
  47   double crs13 = r1 * SG_DEGREES_TO_RADIANS;
  48   double crs23 = r2 * SG_DEGREES_TO_RADIANS;
  49   double dst12 = SGGeodesy::distanceRad(a, b);
  50
  51   //IF sin(lon2-lon1)<0
  52   // crs12=acos((sin(lat2)-sin(lat1)*cos(dst12))/(sin(dst12)*cos(lat1)))
  53   // crs21=2.*pi-acos((sin(lat1)-sin(lat2)*cos(dst12))/(sin(dst12)*cos(lat2)))
  54   // ELSE
  55   // crs12=2.*pi-acos((sin(lat2)-sin(lat1)*cos(dst12))/(sin(dst12)*cos(lat1)))
  56   // crs21=acos((sin(lat1)-sin(lat2)*cos(dst12))/(sin(dst12)*cos(lat2)))
  57   // ENDIF
  58
  59
  60  // double diffLon = b.getLongitudeRad() - a.getLongitudeRad();
  61
  62   double sinLat1 = sin(a.getLatitudeRad());
  63   double cosLat1 = cos(a.getLatitudeRad());
  64  // double sinLat2 = sin(b.getLatitudeRad());
  65   //double cosLat2 = cos(b.getLatitudeRad());
  66   double sinDst12 = sin(dst12);
  67   double cosDst12 = cos(dst12);
  68
  69   double crs12 = SGGeodesy::courseRad(a, b),
  70     crs21 = SGGeodesy::courseRad(b, a);
  71
  72   //double degCrs12 = crs12 * SG_RADIANS_TO_DEGREES;
  73   //double degCrs21 = crs21 * SG_RADIANS_TO_DEGREES;
  74
  75  /*
  76   if (sin(diffLon) < 0.0) {
  77     crs12 = acos((sinLat2 - sinLat1 * cosDst12) / (sinDst12 * cosLat1));
  78     crs21 = SGMiscd::twopi() - acos((sinLat1 - sinLat2*cosDst12)/(sinDst12*cosLat2));
  79   } else {
  80     crs12 = SGMiscd::twopi() - acos((sinLat2 - sinLat1 * cosDst12)/(sinDst12 * cosLat1));
  81     crs21 = acos((sinLat1 - sinLat2 * cosDst12)/(sinDst12 * cosLat2));
  82   }
  83   */
  84
  85   double ang1 = SGMiscd::normalizeAngle2(crs13-crs12);
  86   double ang2 = SGMiscd::normalizeAngle2(crs21-crs23);
  87
  88   if ((sin(ang1) == 0.0) && (sin(ang2) == 0.0)) {
  89     SG_LOG(SG_GENERAL, SG_WARN, "geocRadialIntersection: infinity of intersections");
  90     return false;
  91   }
  92
  93   if ((sin(ang1)*sin(ang2))<0.0) {
  94     SG_LOG(SG_GENERAL, SG_WARN, "geocRadialIntersection: intersection ambiguous");
  95     return false;
  96   }
  97
  98   ang1 = fabs(ang1);
  99   ang2 = fabs(ang2);
 100
 101   //ang3=acos(-cos(ang1)*cos(ang2)+sin(ang1)*sin(ang2)*cos(dst12))
 102   //dst13=atan2(sin(dst12)*sin(ang1)*sin(ang2),cos(ang2)+cos(ang1)*cos(ang3))
 103   //lat3=asin(sin(lat1)*cos(dst13)+cos(lat1)*sin(dst13)*cos(crs13))
 104
 105   //lon3=mod(lon1-dlon+pi,2*pi)-pi
 106
 107   double ang3 = acos(-cos(ang1) * cos(ang2) + sin(ang1) * sin(ang2) * cosDst12);
 108   double dst13 = atan2(sinDst12 * sin(ang1) * sin(ang2), cos(ang2) + cos(ang1)*cos(ang3));
 109
 110   SGGeoc pt3;
 111   SGGeodesy::advanceRadM(a, crs13, dst13 * SG_RAD_TO_NM * SG_NM_TO_METER, pt3);
 112
 113   double lat3 = asin(sinLat1 * cos(dst13) + cosLat1 * sin(dst13) * cos(crs13));
 114
 115   //dlon=atan2(sin(crs13)*sin(dst13)*cos(lat1),cos(dst13)-sin(lat1)*sin(lat3))
 116   double dlon = atan2(sin(crs13)*sin(dst13)*cosLat1, cos(dst13)- (sinLat1 * sin(lat3)));
 117   double lon3 = SGMiscd::normalizeAngle(-a.getLongitudeRad()-dlon);
 118
 119   result = SGGeoc::fromRadM(-lon3, lat3, a.getRadiusM());
 120   //result = pt3;
 121   return true;
 122 }
 123
 124 ////////////////////////////////////////////////////////////////////////////
 125
 126 WayptController::~WayptController()
 127 {
 128 }
 129
 130 void WayptController::init()
 131 {
 132 }
 133
 134 void WayptController::setDone()
 135 {
 136   if (_isDone) {
 137     SG_LOG(SG_AUTOPILOT, SG_WARN, "already done @ WayptController::setDone");
 138   }
 139
 140   _isDone = true;
 141 }
 142
 143 double WayptController::timeToWaypt() const
 144 {
 145   double gs = _rnav->groundSpeedKts();
 146   if (gs < 1.0) {
 147     return -1.0; // stationary
 148   }
 149
 150   gs*= KNOTS_TO_METRES_PER_SECOND;
 151   return (distanceToWayptM() / gs);
 152 }
 153
 154 //////////////
 155
 156 class BasicWayptCtl : public WayptController
 157 {
 158 public:
 159   BasicWayptCtl(RNAV* aRNAV, const WayptRef& aWpt) :
 160     WayptController(aRNAV, aWpt),
 161     _distanceM(0.0),
 162     _courseDev(0.0)
 163   {
 164     if (aWpt->flag(WPT_DYNAMIC)) {
 165       throw sg_exception("BasicWayptCtrl doesn't work with dynamic waypoints");
 166     }
 167   }
 168
 169   virtual void init()
 170   {
 171     _targetTrack = SGGeodesy::courseDeg(_rnav->position(), _waypt->position());
 172   }
 173
 174   virtual void update()
 175   {
 176     double brg, az2;
 177     SGGeodesy::inverse(_rnav->position(), _waypt->position(), brg, az2, _distanceM);
 178     _courseDev = brg - _targetTrack;
 179     SG_NORMALIZE_RANGE(_courseDev, -180.0, 180.0);
 180
 181     if ((fabs(_courseDev) > 90.0) && (_distanceM < _rnav->overflightArmDistanceM())) {
 182       setDone();
 183     }
 184   }
 185
 186   virtual double distanceToWayptM() const
 187   {
 188     return _distanceM;
 189   }
 190
 191   virtual double xtrackErrorNm() const
 192   {
 193     double x = sin(courseDeviationDeg() * SG_DEGREES_TO_RADIANS) * _distanceM;
 194     return x * SG_METER_TO_NM;
 195   }
 196
 197   virtual bool toFlag() const
 198   {
 199     return (fabs(_courseDev) < 90.0);
 200   }
 201
 202   virtual double courseDeviationDeg() const
 203   {
 204     return _courseDev;
 205   }
 206
 207   virtual double trueBearingDeg() const
 208   {
 209     return SGGeodesy::courseDeg(_rnav->position(), _waypt->position());
 210   }
 211
 212   virtual SGGeod position() const
 213   {
 214     return _waypt->position();
 215   }
 216
 217 private:
 218   double _distanceM;
 219   double _courseDev;
 220 };
 221
 222 /**
 223  * Special controller for runways. For runways, we want very narrow deviation
 224  * contraints, and to understand that any point along the paved area is
 225  * equivalent to being 'at' the runway.
 226  */
 227 class RunwayCtl : public WayptController
 228 {
 229 public:
 230   RunwayCtl(RNAV* aRNAV, const WayptRef& aWpt) :
 231     WayptController(aRNAV, aWpt),
 232     _runway(NULL),
 233     _distanceM(0.0),
 234     _courseDev(0.0)
 235   {
 236   }
 237
 238   virtual void init()
 239   {
 240     _runway = static_cast<RunwayWaypt*>(_waypt.get())->runway();
 241     _targetTrack = _runway->headingDeg();
 242   }
 243
 244   virtual void update()
 245   {
 246     double brg, az2;
 247     // use the far end of the runway for course deviation calculations.
 248     // this should do the correct thing both for takeoffs (including entering
 249     // the runway at a taxiway after the threshold) and also landings.
 250     // seperately compute the distance to the threshold for timeToWaypt calc
 251     SGGeodesy::inverse(_rnav->position(), _runway->end(), brg, az2, _distanceM);
 252     double _courseDev = brg - _targetTrack;
 253     SG_NORMALIZE_RANGE(_courseDev, -180.0, 180.0);
 254
 255     if (fabs(_courseDev) > 90.0) {
 256       setDone();
 257     }
 258   }
 259
 260   virtual double distanceToWayptM() const
 261   {
 262     return SGGeodesy::distanceM(_rnav->position(), _runway->threshold());
 263   }
 264
 265   virtual double xtrackErrorNm() const
 266   {
 267     double x = sin(_courseDev * SG_RADIANS_TO_DEGREES) * _distanceM;
 268     return x * SG_METER_TO_NM;
 269   }
 270
 271   virtual double courseDeviationDeg() const
 272   {
 273     return _courseDev;
 274   }
 275
 276   virtual double trueBearingDeg() const
 277   {
 278     // as in update(), use runway->end here, so the value remains
 279     // sensible whether taking off or landing.
 280     return SGGeodesy::courseDeg(_rnav->position(), _runway->end());
 281   }
 282
 283   virtual SGGeod position() const
 284   {
 285     return _runway->threshold();
 286   }
 287 private:
 288   FGRunway* _runway;
 289   double _distanceM;
 290   double _courseDev;
 291 };
 292
 293 class ConstHdgToAltCtl : public WayptController
 294 {
 295 public:
 296   ConstHdgToAltCtl(RNAV* aRNAV, const WayptRef& aWpt) :
 297     WayptController(aRNAV, aWpt)
 298
 299   {
 300     if (_waypt->type() != "hdgToAlt") {
 301       throw sg_exception("invalid waypoint type", "ConstHdgToAltCtl ctor");
 302     }
 303
 304     if (_waypt->altitudeRestriction() == RESTRICT_NONE) {
 305       throw sg_exception("invalid waypoint alt restriction", "ConstHdgToAltCtl ctor");
 306     }
 307   }
 308
 309   virtual void init()
 310   {
 311     HeadingToAltitude* w = (HeadingToAltitude*) _waypt.get();
 312     _targetTrack = w->headingDegMagnetic() + _rnav->magvarDeg();
 313   }
 314
 315   virtual void update()
 316   {
 317     double curAlt = _rnav->position().getElevationFt();
 318
 319     switch (_waypt->altitudeRestriction()) {
 320     case RESTRICT_AT: {
 321       double d = curAlt - _waypt->altitudeFt();
 322       if (fabs(d) < 50.0) {
 323         SG_LOG(SG_GENERAL, SG_INFO, "ConstHdgToAltCtl, reached target altitude " << _waypt->altitudeFt());
 324         setDone();
 325       }
 326     } break;
 327
 328     case RESTRICT_ABOVE:
 329       if (curAlt >= _waypt->altitudeFt()) {
 330         SG_LOG(SG_GENERAL, SG_INFO, "ConstHdgToAltCtl, above target altitude " << _waypt->altitudeFt());
 331         setDone();
 332       }
 333       break;
 334
 335     case RESTRICT_BELOW:
 336       if (curAlt <= _waypt->altitudeFt()) {
 337         SG_LOG(SG_GENERAL, SG_INFO, "ConstHdgToAltCtl, below target altitude " << _waypt->altitudeFt());
 338         setDone();
 339       }
 340       break;
 341
 342     case RESTRICT_NONE:
 343       assert(false);
 344       break;
 345     }
 346   }
 347
 348   virtual double timeToWaypt() const
 349   {
 350     double d = fabs(_rnav->position().getElevationFt() - _waypt->altitudeFt());
 351     return (d / _rnav->vspeedFPM()) * 60.0; // low pass filter here, probably
 352   }
 353
 354   virtual double distanceToWayptM() const
 355   {
 356     double gsMsec = _rnav->groundSpeedKts() * KNOTS_TO_METRES_PER_SECOND;
 357     return timeToWaypt() * gsMsec;
 358   }
 359
 360   virtual SGGeod position() const
 361   {
 362     SGGeod p;
 363     double az2;
 364     SGGeodesy::direct(_rnav->position(), _targetTrack, distanceToWayptM(), p, az2);
 365     return p;
 366   }
 367 };
 368
 369 class InterceptCtl : public WayptController
 370 {
 371 public:
 372   InterceptCtl(RNAV* aRNAV, const WayptRef& aWpt) :
 373     WayptController(aRNAV, aWpt),
 374     _trueRadial(0.0)
 375   {
 376     if (_waypt->type() != "radialIntercept") {
 377       throw sg_exception("invalid waypoint type", "InterceptCtl ctor");
 378     }
 379   }
 380
 381   virtual void init()
 382   {
 383     RadialIntercept* w = (RadialIntercept*) _waypt.get();
 384     _trueRadial = w->radialDegMagnetic() + _rnav->magvarDeg();
 385     _targetTrack = w->courseDegMagnetic() + _rnav->magvarDeg();
 386   }
 387
 388   virtual void update()
 389   {
 390     // note we want the outbound radial from the waypt, hence the ordering
 391     // of arguments to courseDeg
 392     double r = SGGeodesy::courseDeg(_waypt->position(), _rnav->position());
 393     SG_LOG(SG_AUTOPILOT, SG_INFO, "current radial=" << r);
 394     if (fabs(r - _trueRadial) < 0.5) {
 395       SG_LOG(SG_GENERAL, SG_INFO, "InterceptCtl, intercepted radial " << _trueRadial);
 396       setDone();
 397     }
 398   }
 399
 400   virtual double distanceToWayptM() const
 401   {
 402     return SGGeodesy::distanceM(_rnav->position(), position());
 403   }
 404
 405   virtual SGGeod position() const
 406   {
 407     SGGeoc c;
 408     geocRadialIntersection(SGGeoc::fromGeod(_rnav->position()), _rnav->trackDeg(),
 409       SGGeoc::fromGeod(_waypt->position()), _trueRadial, c);
 410     return SGGeod::fromGeoc(c);
 411   }
 412 private:
 413   double _trueRadial;
 414 };
 415
 416 class DMEInterceptCtl : public WayptController
 417 {
 418 public:
 419   DMEInterceptCtl(RNAV* aRNAV, const WayptRef& aWpt) :
 420     WayptController(aRNAV, aWpt),
 421     _dme(NULL),
 422     _distanceNm(0.0)
 423   {
 424     if (_waypt->type() != "dmeIntercept") {
 425       throw sg_exception("invalid waypoint type", "DMEInterceptCtl ctor");
 426     }
 427   }
 428
 429   virtual void init()
 430   {
 431     _dme  = (DMEIntercept*) _waypt.get();
 432     _targetTrack = _dme->courseDegMagnetic() + _rnav->magvarDeg();
 433   }
 434
 435   virtual void update()
 436   {
 437     _distanceNm = SGGeodesy::distanceNm(_rnav->position(), _dme->position());
 438     double d = fabs(_distanceNm - _dme->dmeDistanceNm());
 439     if (d < 0.1) {
 440       SG_LOG(SG_GENERAL, SG_INFO, "DMEInterceptCtl, intercepted DME " << _dme->dmeDistanceNm());
 441       setDone();
 442     }
 443   }
 444
 445   virtual double distanceToWayptM() const
 446   {
 447     return fabs(_distanceNm - _dme->dmeDistanceNm()) * SG_NM_TO_METER;
 448   }
 449
 450   virtual SGGeod position() const
 451   {
 452     SGGeod p;
 453     double az2;
 454     SGGeodesy::direct(_rnav->position(), _targetTrack, distanceToWayptM(), p, az2);
 455     return p;
 456   }
 457
 458 private:
 459   DMEIntercept* _dme;
 460   double _distanceNm;
 461 };
 462
 463 class HoldCtl : public WayptController
 464 {
 465 public:
 466   HoldCtl(RNAV* aRNAV, const WayptRef& aWpt) :
 467     WayptController(aRNAV, aWpt)
 468
 469   {
 470
 471   }
 472
 473   virtual void init()
 474   {
 475   }
 476
 477   virtual void update()
 478   {
 479     // fly inbound / outbound sides, or execute the turn
 480   #if 0
 481     if (inTurn) {
 482
 483       targetTrack += dt * turnRateSec * turnDirection;
 484       if (inbound) {
 485         if .. targetTrack has passed inbound radial, doen with this turn
 486       } else {
 487         if target track has passed reciprocal radial done with turn
 488       }
 489     } else {
 490       check time / distance elapsed
 491
 492       if (sideDone) {
 493         inTurn = true;
 494         inbound = !inbound;
 495         nextHeading = inbound;
 496         if (!inbound) {
 497           nextHeading += 180.0;
 498           SG_NORMALIZE_RANGE(nextHeading, 0.0, 360.0);
 499         }
 500       }
 501
 502     }
 503
 504   #endif
 505     setDone();
 506   }
 507
 508   virtual double distanceToWayptM() const
 509   {
 510     return -1.0;
 511   }
 512
 513   virtual SGGeod position() const
 514   {
 515     return _waypt->position();
 516   }
 517 };
 518
 519 class VectorsCtl : public WayptController
 520 {
 521 public:
 522   VectorsCtl(RNAV* aRNAV, const WayptRef& aWpt) :
 523     WayptController(aRNAV, aWpt)
 524
 525   {
 526   }
 527
 528   virtual void init()
 529   {
 530
 531   }
 532
 533   virtual void update()
 534   {
 535     setDone();
 536   }
 537
 538   virtual double distanceToWayptM() const
 539   {
 540     return -1.0;
 541   }
 542
 543   virtual SGGeod position() const
 544   {
 545     return _waypt->position();
 546   }
 547
 548 private:
 549 };
 550
 551 ///////////////////////////////////////////////////////////////////////////////
 552
 553 DirectToController::DirectToController(RNAV* aRNAV, const WayptRef& aWpt, const SGGeod& aOrigin) :
 554   WayptController(aRNAV, aWpt),
 555   _origin(aOrigin),
 556   _distanceM(0.0),
 557   _courseDev(0.0)
 558 {
 559 }
 560
 561 void DirectToController::init()
 562 {
 563   if (_waypt->flag(WPT_DYNAMIC)) {
 564     throw sg_exception("can't direct-to a dynamic waypoint");
 565   }
 566
 567   _targetTrack = SGGeodesy::courseDeg(_origin, _waypt->position());
 568 }
 569
 570 void DirectToController::update()
 571 {
 572   double brg, az2;
 573   SGGeodesy::inverse(_rnav->position(), _waypt->position(), brg, az2, _distanceM);
 574   _courseDev = brg - _targetTrack;
 575   SG_NORMALIZE_RANGE(_courseDev, -180.0, 180.0);
 576
 577   if ((fabs(_courseDev) > 90.0) && (_distanceM < _rnav->overflightArmDistanceM())) {
 578     setDone();
 579   }
 580 }
 581
 582 double DirectToController::distanceToWayptM() const
 583 {
 584   return _distanceM;
 585 }
 586
 587 double DirectToController::xtrackErrorNm() const
 588 {
 589   double x = sin(courseDeviationDeg() * SG_DEGREES_TO_RADIANS) * _distanceM;
 590   return x * SG_METER_TO_NM;
 591 }
 592
 593 double DirectToController::courseDeviationDeg() const
 594 {
 595   return _courseDev;
 596 }
 597
 598 double DirectToController::trueBearingDeg() const
 599 {
 600   return SGGeodesy::courseDeg(_rnav->position(), _waypt->position());
 601 }
 602
 603 SGGeod DirectToController::position() const
 604 {
 605   return _waypt->position();
 606 }
 607
 608 ///////////////////////////////////////////////////////////////////////////////
 609
 610 OBSController::OBSController(RNAV* aRNAV, const WayptRef& aWpt) :
 611   WayptController(aRNAV, aWpt),
 612   _distanceM(0.0),
 613   _courseDev(0.0)
 614 {
 615 }
 616
 617 void OBSController::init()
 618 {
 619   if (_waypt->flag(WPT_DYNAMIC)) {
 620     throw sg_exception("can't use a dynamic waypoint for OBS mode");
 621   }
 622
 623   _targetTrack = _rnav->selectedMagCourse() + _rnav->magvarDeg();
 624 }
 625
 626 void OBSController::update()
 627 {
 628   _targetTrack = _rnav->selectedMagCourse() + _rnav->magvarDeg();
 629   double brg, az2;
 630   SGGeodesy::inverse(_rnav->position(), _waypt->position(), brg, az2, _distanceM);
 631   _courseDev = brg - _targetTrack;
 632   SG_NORMALIZE_RANGE(_courseDev, -180.0, 180.0);
 633 }
 634
 635 bool OBSController::toFlag() const
 636 {
 637   return (fabs(_courseDev) < 90.0);
 638 }
 639
 640 double OBSController::distanceToWayptM() const
 641 {
 642   return _distanceM;
 643 }
 644
 645 double OBSController::xtrackErrorNm() const
 646 {
 647   double x = sin(_courseDev * SG_DEGREES_TO_RADIANS) * _distanceM;
 648   return x * SG_METER_TO_NM;
 649 }
 650
 651 double OBSController::courseDeviationDeg() const
 652 {
 653 //  if (fabs(_courseDev) > 90.0) {
 654  //   double d = -_courseDev;
 655  //   SG_NORMALIZE_RANGE(d, -90.0, 90.0);
 656   //  return d;
 657   //}
 658
 659   return _courseDev;
 660 }
 661
 662 double OBSController::trueBearingDeg() const
 663 {
 664   return SGGeodesy::courseDeg(_rnav->position(), _waypt->position());
 665 }
 666
 667 SGGeod OBSController::position() const
 668 {
 669   return _waypt->position();
 670 }
 671
 672 ///////////////////////////////////////////////////////////////////////////////
 673
 674 WayptController* WayptController::createForWaypt(RNAV* aRNAV, const WayptRef& aWpt)
 675 {
 676   if (!aWpt) {
 677     throw sg_exception("Passed null waypt", "WayptController::createForWaypt");
 678   }
 679
 680   const std::string& wty(aWpt->type());
 681   if (wty == "runway") {
 682     return new RunwayCtl(aRNAV, aWpt);
 683   }
 684
 685   if (wty == "radialIntercept") {
 686     return new InterceptCtl(aRNAV, aWpt);
 687   }
 688
 689   if (wty == "dmeIntercept") {
 690     return new DMEInterceptCtl(aRNAV, aWpt);
 691   }
 692
 693   if (wty == "hdgToAlt") {
 694     return new ConstHdgToAltCtl(aRNAV, aWpt);
 695   }
 696
 697   if (wty == "vectors") {
 698     return new VectorsCtl(aRNAV, aWpt);
 699   }
 700
 701   if (wty == "hold") {
 702     return new HoldCtl(aRNAV, aWpt);
 703   }
 704
 705   return new BasicWayptCtl(aRNAV, aWpt);
 706 }
 707
 708 } // of namespace flightgear
 709