src/Cockpit/navcom.cxx

   1 // navcom.cxx -- class to manage a navcom instance
   2 //
   3 // Written by Curtis Olson, started April 2000.
   4 //
   5 // Copyright (C) 2000 - 2002  Curtis L. Olson - curt@flightgear.org
   6 //
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License as
   9 // published by the Free Software Foundation; either version 2 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful, but
  13 // WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 // General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software
  19 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 //
  21 // $Id$
  22
  23
  24 #ifdef HAVE_CONFIG_H
  25 #  include <config.h>
  26 #endif
  27
  28 #include <stdio.h>      // snprintf
  29
  30 #include <simgear/compiler.h>
  31 #include <simgear/math/sg_random.h>
  32
  33 #include <Aircraft/aircraft.hxx>
  34 #include <Navaids/ilslist.hxx>
  35 #include <Navaids/mkrbeacons.hxx>
  36 #include <Navaids/navlist.hxx>
  37 #include <Time/FGEventMgr.hxx>
  38
  39 #include "navcom.hxx"
  40
  41 #include <string>
  42 SG_USING_STD(string);
  43
  44
  45 /**
  46  * Boy, this is ugly!  Make the VOR range vary by altitude difference.
  47  */
  48 static double kludgeRange ( double stationElev, double aircraftElev,
  49                             double nominalRange)
  50 {
  51     // Assume that the nominal range (usually 50nm) applies at a 5,000
  52     // ft difference.  Just a wild guess!
  53     double factor = ((aircraftElev*SG_METER_TO_FEET) - stationElev) / 5000.0;
  54     double range = fabs(nominalRange * factor);
  55
  56     // Clamp the range to keep it sane; for now, never less than 25%
  57     // or more than 500% of nominal range.
  58     if (range < nominalRange/4.0) {
  59         range = nominalRange/4.0;
  60     } else if (range > nominalRange*5.0) {
  61         range = nominalRange*5.0;
  62     }
  63
  64     return range;
  65 }
  66
  67
  68 // Constructor
  69 FGNavCom::FGNavCom() :
  70     lon_node(fgGetNode("/position/longitude-deg", true)),
  71     lat_node(fgGetNode("/position/latitude-deg", true)),
  72     alt_node(fgGetNode("/position/altitude-ft", true)),
  73     last_nav_id(""),
  74     last_nav_vor(false),
  75     nav_play_count(0),
  76     nav_last_time(0),
  77     need_update(true),
  78     power_btn(true),
  79     comm_freq(0.0),
  80     comm_alt_freq(0.0),
  81     comm_vol_btn(0.0),
  82     nav_freq(0.0),
  83     nav_alt_freq(0.0),
  84     nav_radial(0.0),
  85     nav_vol_btn(0.0),
  86     nav_ident_btn(true)
  87 {
  88     SGPath path( globals->get_fg_root() );
  89     SGPath term = path;
  90     term.append( "Navaids/range.term" );
  91     SGPath low = path;
  92     low.append( "Navaids/range.low" );
  93     SGPath high = path;
  94     high.append( "Navaids/range.high" );
  95
  96     term_tbl = new SGInterpTable( term.str() );
  97     low_tbl = new SGInterpTable( low.str() );
  98     high_tbl = new SGInterpTable( high.str() );
  99
 100 }
 101
 102
 103 // Destructor
 104 FGNavCom::~FGNavCom()
 105 {
 106     delete term_tbl;
 107     delete low_tbl;
 108     delete high_tbl;
 109 }
 110
 111
 112 void
 113 FGNavCom::init ()
 114 {
 115     morse.init();
 116     beacon.init();
 117
 118     search();
 119
 120     update(0);                  // FIXME: use dt
 121 }
 122
 123 void
 124 FGNavCom::bind ()
 125 {
 126     char propname[256];
 127
 128                                 // User inputs
 129     sprintf( propname, "/radios/comm[%d]/inputs/power-btn", index );
 130     fgTie( propname, this,
 131            &FGNavCom::get_power_btn, &FGNavCom::set_power_btn );
 132     fgSetArchivable( propname );
 133
 134     sprintf( propname, "/radios/comm[%d]/frequencies/selected-mhz", index );
 135     fgTie( propname, this, &FGNavCom::get_comm_freq, &FGNavCom::set_comm_freq );
 136     fgSetArchivable( propname );
 137
 138     sprintf( propname, "/radios/comm[%d]/frequencies/standby-mhz", index );
 139     fgTie( propname, this,
 140            &FGNavCom::get_comm_alt_freq, &FGNavCom::set_comm_alt_freq );
 141     fgSetArchivable( propname );
 142
 143     sprintf( propname, "/radios/comm[%d]/volume", index );
 144     fgTie( propname, this,
 145            &FGNavCom::get_comm_vol_btn, &FGNavCom::set_comm_vol_btn );
 146     fgSetArchivable( propname );
 147
 148     sprintf( propname, "/radios/nav[%d]/frequencies/selected-mhz", index );
 149     fgTie( propname, this,
 150           &FGNavCom::get_nav_freq, &FGNavCom::set_nav_freq );
 151     fgSetArchivable( propname );
 152
 153     sprintf( propname, "/radios/nav[%d]/frequencies/standby-mhz", index );
 154     fgTie( propname , this,
 155            &FGNavCom::get_nav_alt_freq, &FGNavCom::set_nav_alt_freq);
 156     fgSetArchivable( propname );
 157
 158     sprintf( propname, "/radios/nav[%d]/radials/selected-deg", index );
 159     fgTie( propname, this,
 160            &FGNavCom::get_nav_sel_radial, &FGNavCom::set_nav_sel_radial );
 161     fgSetArchivable( propname );
 162
 163     sprintf( propname, "/radios/nav[%d]/volume", index );
 164     fgTie( propname, this,
 165            &FGNavCom::get_nav_vol_btn, &FGNavCom::set_nav_vol_btn );
 166     fgSetArchivable( propname );
 167
 168     sprintf( propname, "/radios/nav[%d]/ident", index );
 169     fgTie( propname, this,
 170            &FGNavCom::get_nav_ident_btn, &FGNavCom::set_nav_ident_btn );
 171     fgSetArchivable( propname );
 172
 173                                 // Radio outputs
 174     sprintf( propname, "/radios/nav[%d]/radials/actual-deg", index );
 175     fgTie( propname,  this, &FGNavCom::get_nav_radial );
 176
 177     sprintf( propname, "/radios/nav[%d]/to-flag", index );
 178     fgTie( propname, this, &FGNavCom::get_nav_to_flag );
 179
 180     sprintf( propname, "/radios/nav[%d]/from-flag", index );
 181     fgTie( propname, this, &FGNavCom::get_nav_from_flag );
 182
 183     sprintf( propname, "/radios/nav[%d]/in-range", index );
 184     fgTie( propname, this, &FGNavCom::get_nav_inrange );
 185
 186     sprintf( propname, "/radios/nav[%d]/heading-needle-deflection", index );
 187     fgTie( propname, this, &FGNavCom::get_nav_heading_needle_deflection );
 188
 189     sprintf( propname, "/radios/nav[%d]/gs-needle-deflection", index );
 190     fgTie( propname, this, &FGNavCom::get_nav_gs_needle_deflection );
 191 }
 192
 193
 194 void
 195 FGNavCom::unbind ()
 196 {
 197     char propname[256];
 198
 199     sprintf( propname, "/radios/comm[%d]/inputs/power-btn", index );
 200     fgUntie( propname );
 201     sprintf( propname, "/radios/comm[%d]/frequencies/selected-mhz", index );
 202     fgUntie( propname );
 203     sprintf( propname, "/radios/comm[%d]/frequencies/standby-mhz", index );
 204     fgUntie( propname );
 205
 206     sprintf( propname, "/radios/nav[%d]/frequencies/selected-mhz", index );
 207     fgUntie( propname );
 208     sprintf( propname, "/radios/nav[%d]/frequencies/standby-mhz", index );
 209     fgUntie( propname );
 210     sprintf( propname, "/radios/nav[%d]/radials/actual-deg", index );
 211     fgUntie( propname );
 212     sprintf( propname, "/radios/nav[%d]/radials/selected-deg", index );
 213     fgUntie( propname );
 214     sprintf( propname, "/radios/nav[%d]/ident", index );
 215     fgUntie( propname );
 216     sprintf( propname, "/radios/nav[%d]/to-flag", index );
 217     fgUntie( propname );
 218     sprintf( propname, "/radios/nav[%d]/from-flag", index );
 219     fgUntie( propname );
 220     sprintf( propname, "/radios/nav[%d]/in-range", index );
 221     fgUntie( propname );
 222     sprintf( propname, "/radios/nav[%d]/heading-needle-deflection", index );
 223     fgUntie( propname );
 224     sprintf( propname, "/radios/nav[%d]/gs-needle-deflection", index );
 225     fgUntie( propname );
 226 }
 227
 228
 229 // model standard VOR/DME/TACAN service volumes as per AIM 1-1-8
 230 double FGNavCom::adjustNavRange( double stationElev, double aircraftElev,
 231                               double nominalRange )
 232 {
 233     // extend out actual usable range to be 1.3x the published safe range
 234     const double usability_factor = 1.3;
 235
 236     // assumptions we model the standard service volume, plus
 237     // ... rather than specifying a cylinder, we model a cone that
 238     // contains the cylinder.  Then we put an upside down cone on top
 239     // to model diminishing returns at too-high altitudes.
 240
 241     // altitude difference
 242     double alt = ( aircraftElev * SG_METER_TO_FEET - stationElev );
 243     // cout << "aircraft elev = " << aircraftElev * SG_METER_TO_FEET
 244     //      << " station elev = " << stationElev << endl;
 245
 246     if ( nominalRange < 25.0 + SG_EPSILON ) {
 247         // Standard Terminal Service Volume
 248         return term_tbl->interpolate( alt ) * usability_factor;
 249     } else if ( nominalRange < 50.0 + SG_EPSILON ) {
 250         // Standard Low Altitude Service Volume
 251         // table is based on range of 40, scale to actual range
 252         return low_tbl->interpolate( alt ) * nominalRange / 40.0
 253             * usability_factor;
 254     } else {
 255         // Standard High Altitude Service Volume
 256         // table is based on range of 130, scale to actual range
 257         return high_tbl->interpolate( alt ) * nominalRange / 130.0
 258             * usability_factor;
 259     }
 260 }
 261
 262
 263 // model standard ILS service volumes as per AIM 1-1-9
 264 double FGNavCom::adjustILSRange( double stationElev, double aircraftElev,
 265                                      double offsetDegrees, double distance )
 266 {
 267     // assumptions we model the standard service volume, plus
 268
 269     // altitude difference
 270     // double alt = ( aircraftElev * SG_METER_TO_FEET - stationElev );
 271     double offset = fabs( offsetDegrees );
 272
 273     if ( offset < 10 ) {
 274         return FG_ILS_DEFAULT_RANGE;
 275     } else if ( offset < 35 ) {
 276         return 10 + (35 - offset) * (FG_ILS_DEFAULT_RANGE - 10) / 25;
 277     } else if ( offset < 45 ) {
 278         return (45 - offset);
 279     } else if ( offset > 170 ) {
 280         return FG_ILS_DEFAULT_RANGE;
 281     } else if ( offset > 145 ) {
 282         return 10 + (offset - 145) * (FG_ILS_DEFAULT_RANGE - 10) / 25;
 283     } else if ( offset > 135 ) {
 284         return (offset - 135);
 285     } else {
 286         return 0;
 287     }
 288 }
 289
 290
 291 // Update the various nav values based on position and valid tuned in navs
 292 void
 293 FGNavCom::update(double dt)
 294 {
 295     double lon = lon_node->getDoubleValue() * SGD_DEGREES_TO_RADIANS;
 296     double lat = lat_node->getDoubleValue() * SGD_DEGREES_TO_RADIANS;
 297     double elev = alt_node->getDoubleValue() * SG_FEET_TO_METER;
 298
 299     need_update = false;
 300
 301     Point3D aircraft = sgGeodToCart( Point3D( lon, lat, elev ) );
 302     Point3D station;
 303     double az1, az2, s;
 304
 305     ////////////////////////////////////////////////////////////////////////
 306     // Nav.
 307     ////////////////////////////////////////////////////////////////////////
 308
 309     if ( nav_valid && power_btn ) {
 310         station = Point3D( nav_x, nav_y, nav_z );
 311         nav_loc_dist = aircraft.distance3D( station );
 312
 313         if ( nav_has_gs ) {
 314             station = Point3D( nav_gs_x, nav_gs_y, nav_gs_z );
 315             nav_gs_dist = aircraft.distance3D( station );
 316         } else {
 317             nav_gs_dist = 0.0;
 318         }
 319
 320         // wgs84 heading
 321         geo_inverse_wgs_84( elev, lat * SGD_RADIANS_TO_DEGREES, lon * SGD_RADIANS_TO_DEGREES,
 322                             nav_loclat, nav_loclon,
 323                             &az1, &az2, &s );
 324         // cout << "az1 = " << az1 << " magvar = " << nav_magvar << endl;
 325         nav_heading = az1 - nav_magvar;
 326         // cout << " heading = " << nav_heading
 327         //      << " dist = " << nav_dist << endl;
 328
 329         if ( nav_loc ) {
 330             double offset = nav_heading - nav_radial;
 331             while ( offset < -180.0 ) { offset += 360.0; }
 332             while ( offset > 180.0 ) { offset -= 360.0; }
 333             // cout << "ils offset = " << offset << endl;
 334             nav_effective_range = adjustILSRange(nav_elev, elev, offset,
 335                                                   nav_loc_dist * SG_METER_TO_NM );
 336         } else {
 337             nav_effective_range = adjustNavRange(nav_elev, elev, nav_range);
 338         }
 339         // cout << "nav range = " << nav_effective_range
 340         //      << " (" << nav_range << ")" << endl;
 341
 342         if ( nav_loc_dist < nav_effective_range * SG_NM_TO_METER ) {
 343             nav_inrange = true;
 344         } else if ( nav_loc_dist < 2 * nav_effective_range * SG_NM_TO_METER ) {
 345             nav_inrange = sg_random() <
 346                 ( 2 * nav_effective_range * SG_NM_TO_METER - nav_loc_dist ) /
 347                 (nav_effective_range * SG_NM_TO_METER);
 348         } else {
 349             nav_inrange = false;
 350         }
 351
 352         if ( !nav_loc ) {
 353             nav_radial = nav_sel_radial;
 354         }
 355     } else {
 356         nav_inrange = false;
 357         // cout << "not picking up vor. :-(" << endl;
 358     }
 359
 360 #ifdef ENABLE_AUDIO_SUPPORT
 361     if ( nav_valid && nav_inrange ) {
 362         // play station ident via audio system if on + ident,
 363         // otherwise turn it off
 364         if ( power_btn && nav_ident_btn ) {
 365             FGSimpleSound *sound;
 366             sound = globals->get_soundmgr()->find( nav_fx_name );
 367             if ( sound != NULL ) {
 368                 sound->set_volume( nav_vol_btn );
 369             } else {
 370                 SG_LOG( SG_COCKPIT, SG_ALERT,
 371                         "Can't find nav-vor-ident sound" );
 372             }
 373             sound = globals->get_soundmgr()->find( dme_fx_name );
 374             if ( sound != NULL ) {
 375                 sound->set_volume( nav_vol_btn );
 376             } else {
 377                 SG_LOG( SG_COCKPIT, SG_ALERT,
 378                         "Can't find nav-dme-ident sound" );
 379             }
 380             cout << "nav_last_time = " << nav_last_time << " ";
 381             cout << "cur_time = " << globals->get_time_params()->get_cur_time();
 382             if ( nav_last_time <
 383                  globals->get_time_params()->get_cur_time() - 30 ) {
 384                 nav_last_time = globals->get_time_params()->get_cur_time();
 385                 nav_play_count = 0;
 386             }
 387             cout << " nav_play_count = " << nav_play_count << endl;
 388             cout << "playing = "
 389                  << globals->get_soundmgr()->is_playing(nav_fx_name)
 390                  << endl;
 391             if ( nav_play_count < 4 ) {
 392                 // play VOR ident
 393                 if ( !globals->get_soundmgr()->is_playing(nav_fx_name) ) {
 394                     globals->get_soundmgr()->play_once( nav_fx_name );
 395                     ++nav_play_count;
 396                 }
 397             } else if ( nav_play_count < 5 && nav_has_dme ) {
 398                 // play DME ident
 399                 if ( !globals->get_soundmgr()->is_playing(nav_fx_name) &&
 400                      !globals->get_soundmgr()->is_playing(dme_fx_name) ) {
 401                     globals->get_soundmgr()->play_once( dme_fx_name );
 402                     ++nav_play_count;
 403                 }
 404             }
 405         } else {
 406             globals->get_soundmgr()->stop( nav_fx_name );
 407             globals->get_soundmgr()->stop( dme_fx_name );
 408         }
 409     }
 410 #endif
 411
 412 }
 413
 414
 415 // Update current nav/adf radio stations based on current postition
 416 void FGNavCom::search()
 417 {
 418     double lon = lon_node->getDoubleValue() * SGD_DEGREES_TO_RADIANS;
 419     double lat = lat_node->getDoubleValue() * SGD_DEGREES_TO_RADIANS;
 420     double elev = alt_node->getDoubleValue() * SG_FEET_TO_METER;
 421
 422     FGILS ils;
 423     FGNav nav;
 424
 425     ////////////////////////////////////////////////////////////////////////
 426     // Nav.
 427     ////////////////////////////////////////////////////////////////////////
 428
 429     if ( current_ilslist->query( lon, lat, elev, nav_freq, &ils ) ) {
 430         nav_id = ils.get_locident();
 431         nav_valid = true;
 432         if ( last_nav_id != nav_id || last_nav_vor ) {
 433             nav_trans_ident = ils.get_trans_ident();
 434             last_nav_id = nav_id;
 435             last_nav_vor = false;
 436             nav_loc = true;
 437             nav_has_dme = ils.get_has_dme();
 438             nav_has_gs = ils.get_has_gs();
 439
 440             nav_loclon = ils.get_loclon();
 441             nav_loclat = ils.get_loclat();
 442             nav_gslon = ils.get_gslon();
 443             nav_gslat = ils.get_gslat();
 444             nav_elev = ils.get_gselev();
 445             nav_magvar = 0;
 446             nav_range = FG_ILS_DEFAULT_RANGE;
 447             nav_effective_range = nav_range;
 448             nav_target_gs = ils.get_gsangle();
 449             nav_radial = ils.get_locheading();
 450             while ( nav_radial <   0.0 ) { nav_radial += 360.0; }
 451             while ( nav_radial > 360.0 ) { nav_radial -= 360.0; }
 452             nav_x = ils.get_x();
 453             nav_y = ils.get_y();
 454             nav_z = ils.get_z();
 455             nav_gs_x = ils.get_gs_x();
 456             nav_gs_y = ils.get_gs_y();
 457             nav_gs_z = ils.get_gs_z();
 458
 459 #ifdef ENABLE_AUDIO_SUPPORT
 460             if ( globals->get_soundmgr()->exists( nav_fx_name ) ) {
 461                 globals->get_soundmgr()->remove( nav_fx_name );
 462             }
 463             FGSimpleSound *sound;
 464             sound = morse.make_ident( nav_trans_ident, LO_FREQUENCY );
 465             sound->set_volume( 0.3 );
 466             globals->get_soundmgr()->add( sound, nav_fx_name );
 467
 468             if ( globals->get_soundmgr()->exists( dme_fx_name ) ) {
 469                 globals->get_soundmgr()->remove( dme_fx_name );
 470             }
 471             sound = morse.make_ident( nav_trans_ident, HI_FREQUENCY );
 472             sound->set_volume( 0.3 );
 473             globals->get_soundmgr()->add( sound, dme_fx_name );
 474
 475             int offset = (int)(sg_random() * 30.0);
 476             nav_play_count = offset / 4;
 477             nav_last_time = globals->get_time_params()->get_cur_time() -
 478                 offset;
 479             cout << "offset = " << offset << " play_count = "
 480                  << nav_play_count
 481                  << " nav_last_time = " << nav_last_time
 482                  << " current time = "
 483                  << globals->get_time_params()->get_cur_time() << endl;
 484 #endif
 485
 486             // cout << "Found an ils station in range" << endl;
 487             // cout << " id = " << ils.get_locident() << endl;
 488         }
 489     } else if ( current_navlist->query( lon, lat, elev, nav_freq, &nav ) ) {
 490         nav_id = nav.get_ident();
 491         nav_valid = true;
 492         if ( last_nav_id != nav_id || !last_nav_vor ) {
 493             last_nav_id = nav_id;
 494             last_nav_vor = true;
 495             nav_trans_ident = nav.get_trans_ident();
 496             nav_loc = false;
 497             nav_has_dme = nav.get_has_dme();
 498             nav_has_gs = false;
 499             nav_loclon = nav.get_lon();
 500             nav_loclat = nav.get_lat();
 501             nav_elev = nav.get_elev();
 502             nav_magvar = nav.get_magvar();
 503             nav_range = nav.get_range();
 504             nav_effective_range = adjustNavRange(nav_elev, elev, nav_range);
 505             nav_target_gs = 0.0;
 506             nav_radial = nav_sel_radial;
 507             nav_x = nav.get_x();
 508             nav_y = nav.get_y();
 509             nav_z = nav.get_z();
 510
 511 #ifdef ENABLE_AUDIO_SUPPORT
 512             if ( globals->get_soundmgr()->exists( nav_fx_name ) ) {
 513                 globals->get_soundmgr()->remove( nav_fx_name );
 514             }
 515             FGSimpleSound *sound;
 516             sound = morse.make_ident( nav_trans_ident, LO_FREQUENCY );
 517             sound->set_volume( 0.3 );
 518             if ( globals->get_soundmgr()->add( sound, nav_fx_name ) ) {
 519                 cout << "Added nav-vor-ident sound" << endl;
 520             } else {
 521                 cout << "Failed to add v1-vor-ident sound" << endl;
 522             }
 523
 524             if ( globals->get_soundmgr()->exists( dme_fx_name ) ) {
 525                 globals->get_soundmgr()->remove( dme_fx_name );
 526             }
 527             sound = morse.make_ident( nav_trans_ident, HI_FREQUENCY );
 528             sound->set_volume( 0.3 );
 529             globals->get_soundmgr()->add( sound, dme_fx_name );
 530
 531             int offset = (int)(sg_random() * 30.0);
 532             nav_play_count = offset / 4;
 533             nav_last_time = globals->get_time_params()->get_cur_time() -
 534                 offset;
 535             cout << "offset = " << offset << " play_count = "
 536                  << nav_play_count << " nav_last_time = "
 537                  << nav_last_time << " current time = "
 538                  << globals->get_time_params()->get_cur_time() << endl;
 539 #endif
 540
 541             // cout << "Found a vor station in range" << endl;
 542             // cout << " id = " << nav.get_ident() << endl;
 543         }
 544     } else {
 545         nav_valid = false;
 546         nav_id = "";
 547         nav_radial = 0;
 548         nav_trans_ident = "";
 549         last_nav_id = "";
 550 #ifdef ENABLE_AUDIO_SUPPORT
 551         if ( ! globals->get_soundmgr()->remove( nav_fx_name ) ) {
 552             cout << "Failed to remove nav-vor-ident sound" << endl;
 553         }
 554         globals->get_soundmgr()->remove( dme_fx_name );
 555 #endif
 556         // cout << "not picking up vor1. :-(" << endl;
 557     }
 558 }
 559
 560
 561 // return the amount of heading needle deflection, returns a value
 562 // clamped to the range of ( -10 , 10 )
 563 double FGNavCom::get_nav_heading_needle_deflection() const {
 564     double r;
 565
 566     if ( nav_inrange ) {
 567         r = nav_heading - nav_radial;
 568         // cout << "Radial = " << nav_radial
 569         //      << "  Bearing = " << nav_heading << endl;
 570
 571         while ( r >  180.0 ) { r -= 360.0;}
 572         while ( r < -180.0 ) { r += 360.0;}
 573         if ( fabs(r) > 90.0 ) {
 574             r = ( r<0.0 ? -r-180.0 : -r+180.0 );
 575             if ( nav_loc ) {
 576                 r = -r;
 577             }
 578         }
 579
 580         // According to Robin Peel, the ILS is 4x more sensitive than a vor
 581         if ( nav_loc ) { r *= 4.0; }
 582         if ( r < -10.0 ) { r = -10.0; }
 583         if ( r >  10.0 ) { r = 10.0; }
 584     } else {
 585         r = 0.0;
 586     }
 587
 588     return r;
 589 }
 590
 591
 592 // return the amount of glide slope needle deflection (.i.e. the
 593 // number of degrees we are off the glide slope * 5.0
 594 double FGNavCom::get_nav_gs_needle_deflection() const {
 595     if ( nav_inrange && nav_has_gs ) {
 596         double x = nav_gs_dist;
 597         double y = (fgGetDouble("/position/altitude-ft") - nav_elev)
 598             * SG_FEET_TO_METER;
 599         double angle = atan2( y, x ) * SGD_RADIANS_TO_DEGREES;
 600         return (nav_target_gs - angle) * 5.0;
 601     } else {
 602         return 0.0;
 603     }
 604 }
 605
 606
 607 /**
 608  * Return true if the NAV TO flag should be active.
 609  */
 610 bool
 611 FGNavCom::get_nav_to_flag () const
 612 {
 613   if (nav_inrange) {
 614     double offset = fabs(nav_heading - nav_radial);
 615     if (nav_loc)
 616       return true;
 617     else
 618       return (offset <= 90.0 || offset >= 270.0);
 619   } else {
 620     return false;
 621   }
 622 }
 623
 624
 625 /**
 626  * Return true if the NAV FROM flag should be active.
 627  */
 628 bool
 629 FGNavCom::get_nav_from_flag () const
 630 {
 631   if (nav_inrange) {
 632     double offset = fabs(nav_heading - nav_radial);
 633     if (nav_loc)
 634       return false;
 635     else
 636       return (offset > 90.0 && offset < 270.0);
 637   } else {
 638     return false;
 639   }
 640 }