src/Cockpit/radiostack.cxx

   1 // radiostack.cxx -- class to manage an instance of the radio stack
   2 //
   3 // Written by Curtis Olson, started April 2000.
   4 //
   5 // Copyright (C) 2000  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 <simgear/compiler.h>
  29 #include <simgear/math/sg_random.h>
  30
  31 #include <Aircraft/aircraft.hxx>
  32 #include <Main/bfi.hxx>
  33 #include <Navaids/ilslist.hxx>
  34 #include <Navaids/mkrbeacons.hxx>
  35 #include <Navaids/navlist.hxx>
  36 #include <Time/event.hxx>
  37
  38 #include "radiostack.hxx"
  39
  40 static int nav1_play_count = 0;
  41 static int nav2_play_count = 0;
  42 static int adf_play_count = 0;
  43 static time_t nav1_last_time = 0;
  44 static time_t nav2_last_time = 0;
  45 static time_t adf_last_time = 0;
  46
  47
  48 FGRadioStack *current_radiostack;
  49
  50
  51 /**
  52  * Boy, this is ugly!  Make the VOR range vary by altitude difference.
  53  */
  54 static double kludgeRange ( double stationElev, double aircraftElev,
  55                             double nominalRange)
  56 {
  57                                 // Assume that the nominal range (usually
  58                                 // 50nm) applies at a 5,000 ft difference.
  59                                 // Just a wild guess!
  60   double factor = ((aircraftElev*SG_METER_TO_FEET) - stationElev) / 5000.0;
  61   double range = fabs(nominalRange * factor);
  62
  63                                 // Clamp the range to keep it sane; for
  64                                 // now, never less than 25% or more than
  65                                 // 500% of nominal range.
  66   if (range < nominalRange/4.0) {
  67     range = nominalRange/4.0;
  68   } else if (range > nominalRange*5.0) {
  69     range = nominalRange*5.0;
  70   }
  71
  72   return range;
  73 }
  74
  75
  76 // periodic radio station search wrapper
  77 static void fgRadioSearch( void ) {
  78     current_radiostack->search();
  79 }
  80
  81 // Constructor
  82 FGRadioStack::FGRadioStack() {
  83     nav1_radial = 0.0;
  84     nav1_dme_dist = 0.0;
  85     nav2_radial = 0.0;
  86     nav2_dme_dist = 0.0;
  87     need_update = true;
  88     longitudeVal = fgGetValue("/position/longitude");
  89     latitudeVal = fgGetValue("/position/latitude");
  90     altitudeVal = fgGetValue("/position/altitude");
  91 }
  92
  93
  94 // Destructor
  95 FGRadioStack::~FGRadioStack()
  96 {
  97     unbind();                   // FIXME: should be called externally
  98 }
  99
 100
 101 void
 102 FGRadioStack::init ()
 103 {
 104     morse.init();
 105     beacon.init();
 106     blink.stamp();
 107
 108     search();
 109     update();
 110
 111     SGPath path( globals->get_fg_root() );
 112     SGPath term = path;
 113     term.append( "Navaids/range.term" );
 114     SGPath low = path;
 115     low.append( "Navaids/range.low" );
 116     SGPath high = path;
 117     high.append( "Navaids/range.high" );
 118
 119     term_tbl = new SGInterpTable( term.str() );
 120     low_tbl = new SGInterpTable( low.str() );
 121     high_tbl = new SGInterpTable( high.str() );
 122
 123     // Search radio database once per second
 124     global_events.Register( "fgRadioSearch()", fgRadioSearch,
 125                             fgEVENT::FG_EVENT_READY, 1000);
 126 }
 127
 128 void
 129 FGRadioStack::bind ()
 130 {
 131                                 // User inputs
 132     fgTie("/radios/nav1/frequencies/selected", this,
 133           &FGRadioStack::get_nav1_freq, &FGRadioStack::set_nav1_freq);
 134     fgTie("/radios/nav1/frequencies/standby", this,
 135           &FGRadioStack::get_nav1_alt_freq, &FGRadioStack::set_nav1_alt_freq);
 136     fgTie("/radios/nav1/radials/selected", this,
 137           &FGRadioStack::get_nav1_sel_radial,
 138           &FGRadioStack::set_nav1_sel_radial);
 139     fgTie("/radios/nav1/volume", this,
 140           &FGRadioStack::get_nav1_vol_btn,
 141           &FGRadioStack::set_nav1_vol_btn);
 142     fgTie("/radios/nav1/ident", this,
 143           &FGRadioStack::get_nav1_ident_btn,
 144           &FGRadioStack::set_nav1_ident_btn);
 145
 146                                 // Radio outputs
 147     fgTie("/radios/nav1/radials/actual", this, &FGRadioStack::get_nav1_radial);
 148     fgTie("/radios/nav1/to-flag", this, &FGRadioStack::get_nav1_to_flag);
 149     fgTie("/radios/nav1/from-flag", this, &FGRadioStack::get_nav1_from_flag);
 150     fgTie("/radios/nav1/in-range", this, &FGRadioStack::get_nav1_inrange);
 151     fgTie("/radios/nav1/dme/distance", this, &FGRadioStack::get_nav1_dme_dist);
 152     fgTie("/radios/nav1/dme/in-range", this,
 153           &FGRadioStack::get_nav1_dme_inrange);
 154     fgTie("/radios/nav1/heading-needle-deflection", this,
 155           &FGRadioStack::get_nav1_heading_needle_deflection);
 156     fgTie("/radios/nav1/gs-needle-deflection", this,
 157           &FGRadioStack::get_nav1_gs_needle_deflection);
 158
 159                                 // User inputs
 160     fgTie("/radios/nav2/frequencies/selected", this,
 161           &FGRadioStack::get_nav2_freq, &FGRadioStack::set_nav2_freq);
 162     fgTie("/radios/nav2/frequencies/standby", this,
 163           &FGRadioStack::get_nav2_alt_freq, &FGRadioStack::set_nav2_alt_freq);
 164     fgTie("/radios/nav2/radials/selected", this,
 165           &FGRadioStack::get_nav2_sel_radial,
 166           &FGRadioStack::set_nav2_sel_radial);
 167     fgTie("/radios/nav2/volume", this,
 168           &FGRadioStack::get_nav2_vol_btn,
 169           &FGRadioStack::set_nav2_vol_btn);
 170     fgTie("/radios/nav2/ident", this,
 171           &FGRadioStack::get_nav2_ident_btn,
 172           &FGRadioStack::set_nav2_ident_btn);
 173
 174                                 // Radio outputs
 175     fgTie("/radios/nav2/radials/actual", this, &FGRadioStack::get_nav2_radial);
 176     fgTie("/radios/nav2/to-flag", this, &FGRadioStack::get_nav2_to_flag);
 177     fgTie("/radios/nav2/from-flag", this, &FGRadioStack::get_nav2_from_flag);
 178     fgTie("/radios/nav2/in-range", this, &FGRadioStack::get_nav2_inrange);
 179     fgTie("/radios/nav2/dme/distance", this, &FGRadioStack::get_nav2_dme_dist);
 180     fgTie("/radios/nav2/dme/in-range", this,
 181           &FGRadioStack::get_nav2_dme_inrange);
 182     fgTie("/radios/nav2/heading-needle-deflection", this,
 183           &FGRadioStack::get_nav2_heading_needle_deflection);
 184     fgTie("/radios/nav2/gs-needle-deflection", this,
 185           &FGRadioStack::get_nav2_gs_needle_deflection);
 186
 187                                 // User inputs
 188     fgTie("/radios/adf/frequencies/selected", this,
 189           &FGRadioStack::get_adf_freq, &FGRadioStack::set_adf_freq);
 190     fgTie("/radios/adf/frequencies/standby", this,
 191           &FGRadioStack::get_adf_alt_freq, &FGRadioStack::set_adf_alt_freq);
 192     fgTie("/radios/adf/rotation", this,
 193           &FGRadioStack::get_adf_rotation, &FGRadioStack::set_adf_rotation);
 194     fgTie("/radios/adf/volume", this,
 195           &FGRadioStack::get_adf_vol_btn,
 196           &FGRadioStack::set_adf_vol_btn);
 197     fgTie("/radios/adf/ident", this,
 198           &FGRadioStack::get_adf_ident_btn,
 199           &FGRadioStack::set_adf_ident_btn);
 200
 201     fgTie("/radios/marker-beacon/inner", this,
 202           &FGRadioStack::get_inner_blink);
 203     fgTie("/radios/marker-beacon/middle", this,
 204           &FGRadioStack::get_middle_blink);
 205     fgTie("/radios/marker-beacon/outer", this,
 206           &FGRadioStack::get_outer_blink);
 207 }
 208
 209 void
 210 FGRadioStack::unbind ()
 211 {
 212     fgUntie("/radios/nav1/frequencies/selected");
 213     fgUntie("/radios/nav1/frequencies/standby");
 214     fgUntie("/radios/nav1/radials/actual");
 215     fgUntie("/radios/nav1/radials/selected");
 216     fgUntie("/radios/nav1/on");
 217     fgUntie("/radios/nav1/ident");
 218     fgUntie("/radios/nav1/to-flag");
 219     fgUntie("/radios/nav1/from-flag");
 220     fgUntie("/radios/nav1/in-range");
 221     fgUntie("/radios/nav1/dme/distance");
 222     fgUntie("/radios/nav1/dme/in-range");
 223     fgUntie("/radios/nav1/heading-needle-deflection");
 224     fgUntie("/radios/nav1/gs-needle-deflection");
 225
 226     fgUntie("/radios/nav2/frequencies/selected");
 227     fgUntie("/radios/nav2/frequencies/standby");
 228     fgUntie("/radios/nav2/radials/actual");
 229     fgUntie("/radios/nav2/radials/selected");
 230     fgUntie("/radios/nav2/on");
 231     fgUntie("/radios/nav2/ident");
 232     fgUntie("/radios/nav2/to-flag");
 233     fgUntie("/radios/nav2/from-flag");
 234     fgUntie("/radios/nav2/in-range");
 235     fgUntie("/radios/nav2/dme/distance");
 236     fgUntie("/radios/nav2/dme/in-range");
 237     fgUntie("/radios/nav2/heading-needle-deflection");
 238     fgUntie("/radios/nav2/gs-needle-deflection");
 239
 240     fgUntie("/radios/adf/frequencies/selected");
 241     fgUntie("/radios/adf/frequencies/standby");
 242     fgUntie("/radios/adf/rotation");
 243     fgUntie("/radios/adf/on");
 244     fgUntie("/radios/adf/ident");
 245
 246     fgUntie("/radios/marker-beacon/inner");
 247     fgUntie("/radios/marker-beacon/middle");
 248     fgUntie("/radios/marker-beacon/outer");
 249 }
 250
 251
 252 // model standard VOR/DME/TACAN service volumes as per AIM 1-1-8
 253 double FGRadioStack::adjustNavRange( double stationElev, double aircraftElev,
 254                               double nominalRange )
 255 {
 256     // extend out actual usable range to be 1.3x the published safe range
 257     const double usability_factor = 1.3;
 258
 259     // assumptions we model the standard service volume, plus
 260     // ... rather than specifying a cylinder, we model a cone that
 261     // contains the cylinder.  Then we put an upside down cone on top
 262     // to model diminishing returns at too-high altitudes.
 263
 264     // altitude difference
 265     double alt = ( aircraftElev * SG_METER_TO_FEET - stationElev );
 266     // cout << "aircraft elev = " << aircraftElev * SG_METER_TO_FEET
 267     //      << " station elev = " << stationElev << endl;
 268
 269     if ( nominalRange < 25.0 + SG_EPSILON ) {
 270         // Standard Terminal Service Volume
 271         return term_tbl->interpolate( alt ) * usability_factor;
 272     } else if ( nominalRange < 50.0 + SG_EPSILON ) {
 273         // Standard Low Altitude Service Volume
 274         // table is based on range of 40, scale to actual range
 275         return low_tbl->interpolate( alt ) * nominalRange / 40.0
 276             * usability_factor;
 277     } else {
 278         // Standard High Altitude Service Volume
 279         // table is based on range of 130, scale to actual range
 280         return high_tbl->interpolate( alt ) * nominalRange / 130.0
 281             * usability_factor;
 282     }
 283 }
 284
 285
 286 // model standard ILS service volumes as per AIM 1-1-9
 287 double FGRadioStack::adjustILSRange( double stationElev, double aircraftElev,
 288                                      double offsetDegrees, double distance )
 289 {
 290     // assumptions we model the standard service volume, plus
 291
 292     // altitude difference
 293     // double alt = ( aircraftElev * SG_METER_TO_FEET - stationElev );
 294     double offset = fabs( offsetDegrees );
 295
 296     if ( offset < 10 ) {
 297         return FG_ILS_DEFAULT_RANGE;
 298     } else if ( offset < 35 ) {
 299         return 10 + (35 - offset) * (FG_ILS_DEFAULT_RANGE - 10) / 25;
 300     } else if ( offset < 45 ) {
 301         return (45 - offset);
 302     } else {
 303         return 0;
 304     }
 305 }
 306
 307
 308 // Update the various nav values based on position and valid tuned in navs
 309 void
 310 FGRadioStack::update()
 311 {
 312     double lon = longitudeVal->getDoubleValue() * SGD_DEGREES_TO_RADIANS;
 313     double lat = latitudeVal->getDoubleValue() * SGD_DEGREES_TO_RADIANS;
 314     double elev = altitudeVal->getDoubleValue() * SG_FEET_TO_METER;
 315
 316     need_update = false;
 317
 318     Point3D aircraft = sgGeodToCart( Point3D( lon, lat, elev ) );
 319     Point3D station;
 320     double az1, az2, s;
 321
 322     if ( nav1_valid ) {
 323         station = Point3D( nav1_x, nav1_y, nav1_z );
 324         nav1_loc_dist = aircraft.distance3D( station );
 325
 326         if ( nav1_has_dme ) {
 327             // staightline distance
 328             station = Point3D( nav1_dme_x, nav1_dme_y, nav1_dme_z );
 329             nav1_dme_dist = aircraft.distance3D( station );
 330         } else {
 331             nav1_dme_dist = 0.0;
 332         }
 333
 334         if ( nav1_has_gs ) {
 335             station = Point3D( nav1_gs_x, nav1_gs_y, nav1_gs_z );
 336             nav1_gs_dist = aircraft.distance3D( station );
 337         } else {
 338             nav1_gs_dist = 0.0;
 339         }
 340
 341         // wgs84 heading
 342         geo_inverse_wgs_84( elev, lat * SGD_RADIANS_TO_DEGREES, lon * SGD_RADIANS_TO_DEGREES,
 343                             nav1_loclat, nav1_loclon,
 344                             &az1, &az2, &s );
 345         // cout << "az1 = " << az1 << " magvar = " << nav1_magvar << endl;
 346         nav1_heading = az1 - nav1_magvar;
 347         // cout << " heading = " << nav1_heading
 348         //      << " dist = " << nav1_dist << endl;
 349
 350         if ( nav1_loc ) {
 351             double offset = nav1_heading - nav1_radial;
 352             while ( offset < -180.0 ) { offset += 360.0; }
 353             while ( offset > 180.0 ) { offset -= 360.0; }
 354             // cout << "ils offset = " << offset << endl;
 355             nav1_effective_range = adjustILSRange(nav1_elev, elev, offset,
 356                                                   nav1_loc_dist * SG_METER_TO_NM );
 357         } else {
 358             nav1_effective_range = adjustNavRange(nav1_elev, elev, nav1_range);
 359         }
 360         // cout << "nav1 range = " << nav1_effective_range
 361         //      << " (" << nav1_range << ")" << endl;
 362
 363         if ( nav1_loc_dist < nav1_effective_range * SG_NM_TO_METER ) {
 364             nav1_inrange = true;
 365         } else if ( nav1_loc_dist < 2 * nav1_effective_range * SG_NM_TO_METER ) {
 366             nav1_inrange = sg_random() <
 367                 ( 2 * nav1_effective_range * SG_NM_TO_METER - nav1_loc_dist ) /
 368                 (nav1_effective_range * SG_NM_TO_METER);
 369         } else {
 370             nav1_inrange = false;
 371         }
 372
 373         if ( !nav1_loc ) {
 374             nav1_radial = nav1_sel_radial;
 375         }
 376     } else {
 377         nav1_inrange = false;
 378         nav1_dme_dist = 0.0;
 379         // cout << "not picking up vor. :-(" << endl;
 380     }
 381
 382 #ifdef ENABLE_AUDIO_SUPPORT
 383     if ( nav1_valid && nav1_inrange ) {
 384         // play station ident via audio system if on + ident,
 385         // otherwise turn it off
 386         if ( nav1_vol_btn > 0.1 && nav1_ident_btn ) {
 387             FGSimpleSound *sound;
 388             sound = globals->get_soundmgr()->find( "nav1-vor-ident" );
 389             sound->set_volume( nav1_vol_btn * 0.3 );
 390             sound = globals->get_soundmgr()->find( "nav1-dme-ident" );
 391             sound->set_volume( nav1_vol_btn * 0.3 );
 392             if ( nav1_last_time <
 393                  globals->get_time_params()->get_cur_time() - 30 ) {
 394                 nav1_last_time = globals->get_time_params()->get_cur_time();
 395                 nav1_play_count = 0;
 396             }
 397             if ( nav1_play_count < 4 ) {
 398                 // play VOR ident
 399                 if ( !globals->get_soundmgr()->is_playing("nav1-vor-ident") ) {
 400                     globals->get_soundmgr()->play_once( "nav1-vor-ident" );
 401                     ++nav1_play_count;
 402                 }
 403             } else if ( nav1_play_count < 5 && nav1_has_dme ) {
 404                 // play DME ident
 405                 if ( !globals->get_soundmgr()->is_playing("nav1-vor-ident") &&
 406                      !globals->get_soundmgr()->is_playing("nav1-dme-ident") ) {
 407                     globals->get_soundmgr()->play_once( "nav1-dme-ident" );
 408                     ++nav1_play_count;
 409                 }
 410             }
 411         } else {
 412             globals->get_soundmgr()->stop( "nav1-vor-ident" );
 413             globals->get_soundmgr()->stop( "nav1-dme-ident" );
 414         }
 415     }
 416 #endif
 417
 418     if ( nav2_valid ) {
 419         station = Point3D( nav2_x, nav2_y, nav2_z );
 420         nav2_loc_dist = aircraft.distance3D( station );
 421
 422         if ( nav2_has_dme ) {
 423             // staightline distance
 424             station = Point3D( nav2_dme_x, nav2_dme_y, nav2_dme_z );
 425             nav2_dme_dist = aircraft.distance3D( station );
 426         } else {
 427             nav2_dme_dist = 0.0;
 428         }
 429
 430         if ( nav2_has_gs ) {
 431             station = Point3D( nav2_gs_x, nav2_gs_y, nav2_gs_z );
 432             nav2_gs_dist = aircraft.distance3D( station );
 433         } else {
 434             nav2_gs_dist = 0.0;
 435         }
 436
 437         // wgs84 heading
 438         geo_inverse_wgs_84( elev, lat * SGD_RADIANS_TO_DEGREES, lon * SGD_RADIANS_TO_DEGREES,
 439                             nav2_loclat, nav2_loclon,
 440                             &az1, &az2, &s );
 441         nav2_heading = az1 - nav2_magvar;
 442         // cout << " heading = " << nav2_heading
 443         //      << " dist = " << nav2_dist << endl;
 444
 445         if ( nav2_loc ) {
 446             double offset = nav2_heading - nav2_radial;
 447             while ( offset < -180.0 ) { offset += 360.0; }
 448             while ( offset > 180.0 ) { offset -= 360.0; }
 449             // cout << "ils offset = " << offset << endl;
 450             nav2_effective_range = adjustILSRange(nav2_elev, elev, offset,
 451                                                   nav2_loc_dist * SG_METER_TO_NM );
 452         } else {
 453             nav2_effective_range = adjustNavRange(nav2_elev, elev, nav2_range);
 454         }
 455         // cout << "nav2 range = " << nav2_effective_range
 456         //      << " (" << nav2_range << ")" << endl;
 457
 458         if ( nav2_loc_dist < nav2_effective_range * SG_NM_TO_METER ) {
 459             nav2_inrange = true;
 460         } else if ( nav2_loc_dist < 2 * nav2_effective_range * SG_NM_TO_METER ) {
 461             nav2_inrange = sg_random() <
 462                 ( 2 * nav2_effective_range * SG_NM_TO_METER - nav2_loc_dist ) /
 463                 (nav2_effective_range * SG_NM_TO_METER);
 464         } else {
 465             nav2_inrange = false;
 466         }
 467
 468         if ( !nav2_loc ) {
 469             nav2_radial = nav2_sel_radial;
 470         }
 471     } else {
 472         nav2_inrange = false;
 473         nav2_dme_dist = 0.0;
 474         // cout << "not picking up vor. :-(" << endl;
 475     }
 476
 477 #ifdef ENABLE_AUDIO_SUPPORT
 478     if ( nav2_valid && nav2_inrange ) {
 479         // play station ident via audio system if on + ident,
 480         // otherwise turn it off
 481         if ( nav2_vol_btn > 0.1 && nav2_ident_btn ) {
 482             FGSimpleSound *sound;
 483             sound = globals->get_soundmgr()->find( "nav2-vor-ident" );
 484             sound->set_volume( nav2_vol_btn * 0.3 );
 485             sound = globals->get_soundmgr()->find( "nav2-dme-ident" );
 486             sound->set_volume( nav2_vol_btn * 0.3 );
 487             if ( nav2_last_time <
 488                  globals->get_time_params()->get_cur_time() - 30 ) {
 489                 nav2_last_time = globals->get_time_params()->get_cur_time();
 490                 nav2_play_count = 0;
 491             }
 492             if ( nav2_play_count < 4 ) {
 493                 // play VOR ident
 494                 if ( !globals->get_soundmgr()->is_playing("nav2-vor-ident") ) {
 495                     globals->get_soundmgr()->play_once( "nav2-vor-ident" );
 496                     ++nav2_play_count;
 497                 }
 498             } else if ( nav2_play_count < 5 && nav2_has_dme ) {
 499                 // play DME ident
 500                 if ( !globals->get_soundmgr()->is_playing("nav2-vor-ident") &&
 501                      !globals->get_soundmgr()->is_playing("nav2-dme-ident") ) {
 502                     globals->get_soundmgr()->play_once( "nav2-dme-ident" );
 503                     ++nav2_play_count;
 504                 }
 505             }
 506         } else {
 507             globals->get_soundmgr()->stop( "nav2-vor-ident" );
 508             globals->get_soundmgr()->stop( "nav2-dme-ident" );
 509         }
 510     }
 511 #endif
 512
 513     // adf
 514     if ( adf_valid ) {
 515         // staightline distance
 516         station = Point3D( adf_x, adf_y, adf_z );
 517         adf_dist = aircraft.distance3D( station );
 518
 519         // wgs84 heading
 520         geo_inverse_wgs_84( elev, lat * SGD_RADIANS_TO_DEGREES, lon * SGD_RADIANS_TO_DEGREES,
 521                             adf_lat, adf_lon,
 522                             &az1, &az2, &s );
 523         adf_heading = az1;
 524         // cout << " heading = " << nav2_heading
 525         //      << " dist = " << nav2_dist << endl;
 526
 527         adf_effective_range = kludgeRange(adf_elev, elev, adf_range);
 528         if ( adf_dist < adf_effective_range * SG_NM_TO_METER ) {
 529             adf_inrange = true;
 530         } else if ( adf_dist < 2 * adf_effective_range * SG_NM_TO_METER ) {
 531             adf_inrange = sg_random() <
 532                 ( 2 * adf_effective_range * SG_NM_TO_METER - adf_dist ) /
 533                 (adf_effective_range * SG_NM_TO_METER);
 534         } else {
 535             adf_inrange = false;
 536         }
 537     } else {
 538         adf_inrange = false;
 539     }
 540
 541 #ifdef ENABLE_AUDIO_SUPPORT
 542     if ( adf_valid && adf_inrange ) {
 543         // play station ident via audio system if on + ident,
 544         // otherwise turn it off
 545         if ( adf_vol_btn > 0.1 && adf_ident_btn ) {
 546             FGSimpleSound *sound;
 547             sound = globals->get_soundmgr()->find( "adf-ident" );
 548             sound->set_volume( adf_vol_btn * 0.3 );
 549             if ( adf_last_time <
 550                  globals->get_time_params()->get_cur_time() - 30 ) {
 551                 adf_last_time = globals->get_time_params()->get_cur_time();
 552                 adf_play_count = 0;
 553             }
 554             if ( adf_play_count < 4 ) {
 555                 // play ADF ident
 556                 if ( !globals->get_soundmgr()->is_playing("adf-ident") ) {
 557                     globals->get_soundmgr()->play_once( "adf-ident" );
 558                     ++adf_play_count;
 559                 }
 560             }
 561         } else {
 562             globals->get_soundmgr()->stop( "adf-ident" );
 563         }
 564     }
 565 #endif
 566
 567     // marker beacon blinking
 568     bool light_on = ( outer_blink || middle_blink || inner_blink );
 569     SGTimeStamp current;
 570     current.stamp();
 571
 572     if ( light_on && (current - blink > 400000) ) {
 573         light_on = false;
 574         blink.stamp();
 575     } else if ( !light_on && (current - blink > 100000) ) {
 576         light_on = true;
 577         blink.stamp();
 578     }
 579
 580     if ( outer_marker ) {
 581         outer_blink = light_on;
 582     } else {
 583         outer_blink = false;
 584     }
 585
 586     if ( middle_marker ) {
 587         middle_blink = light_on;
 588     } else {
 589         middle_blink = false;
 590     }
 591
 592     if ( inner_marker ) {
 593         inner_blink = light_on;
 594     } else {
 595         inner_blink = false;
 596     }
 597
 598     // cout << outer_blink << " " << middle_blink << " " << inner_blink << endl;
 599 }
 600
 601
 602 // Update current nav/adf radio stations based on current postition
 603 void FGRadioStack::search()
 604 {
 605     static FGMkrBeacon::fgMkrBeacType last_beacon = FGMkrBeacon::NOBEACON;
 606
 607     double lon = longitudeVal->getDoubleValue() * SGD_DEGREES_TO_RADIANS;
 608     double lat = latitudeVal->getDoubleValue() * SGD_DEGREES_TO_RADIANS;
 609     double elev = altitudeVal->getDoubleValue() * SG_FEET_TO_METER;
 610
 611     // nav1
 612     FGILS ils;
 613     FGNav nav;
 614
 615     static string last_nav1_ident = "";
 616     static string last_nav2_ident = "";
 617     static string last_adf_ident = "";
 618     static bool last_nav1_vor = false;
 619     static bool last_nav2_vor = false;
 620     if ( current_ilslist->query( lon, lat, elev, nav1_freq, &ils ) ) {
 621         nav1_ident = ils.get_locident();
 622         nav1_valid = true;
 623         if ( last_nav1_ident != nav1_ident || last_nav1_vor ) {
 624             nav1_trans_ident = ils.get_trans_ident();
 625             last_nav1_ident = nav1_ident;
 626             last_nav1_vor = false;
 627             nav1_loc = true;
 628             nav1_has_dme = ils.get_has_dme();
 629             nav1_has_gs = ils.get_has_gs();
 630
 631             nav1_loclon = ils.get_loclon();
 632             nav1_loclat = ils.get_loclat();
 633             nav1_gslon = ils.get_gslon();
 634             nav1_gslat = ils.get_gslat();
 635             nav1_dmelon = ils.get_dmelon();
 636             nav1_dmelat = ils.get_dmelat();
 637             nav1_elev = ils.get_gselev();
 638             nav1_magvar = 0;
 639             nav1_range = FG_ILS_DEFAULT_RANGE;
 640             nav1_effective_range = nav1_range;
 641             nav1_target_gs = ils.get_gsangle();
 642             nav1_radial = ils.get_locheading();
 643             while ( nav1_radial <   0.0 ) { nav1_radial += 360.0; }
 644             while ( nav1_radial > 360.0 ) { nav1_radial -= 360.0; }
 645             nav1_x = ils.get_x();
 646             nav1_y = ils.get_y();
 647             nav1_z = ils.get_z();
 648             nav1_gs_x = ils.get_gs_x();
 649             nav1_gs_y = ils.get_gs_y();
 650             nav1_gs_z = ils.get_gs_z();
 651             nav1_dme_x = ils.get_dme_x();
 652             nav1_dme_y = ils.get_dme_y();
 653             nav1_dme_z = ils.get_dme_z();
 654
 655 #ifdef ENABLE_AUDIO_SUPPORT
 656             if ( globals->get_soundmgr()->exists( "nav1-vor-ident" ) ) {
 657                 globals->get_soundmgr()->remove( "nav1-vor-ident" );
 658             }
 659             FGSimpleSound *sound;
 660             sound = morse.make_ident( nav1_trans_ident, LO_FREQUENCY );
 661             sound->set_volume( 0.3 );
 662             globals->get_soundmgr()->add( sound, "nav1-vor-ident" );
 663
 664             if ( globals->get_soundmgr()->exists( "nav1-dme-ident" ) ) {
 665                 globals->get_soundmgr()->remove( "nav1-dme-ident" );
 666             }
 667             sound = morse.make_ident( nav1_trans_ident, HI_FREQUENCY );
 668             sound->set_volume( 0.3 );
 669             globals->get_soundmgr()->add( sound, "nav1-dme-ident" );
 670
 671             int offset = (int)(sg_random() * 30.0);
 672             nav1_play_count = offset / 4;
 673             nav1_last_time = globals->get_time_params()->get_cur_time() -
 674                 offset;
 675             // cout << "offset = " << offset << " play_count = "
 676             //      << nav1_play_count
 677             //      << " nav1_last_time = " << nav1_last_time
 678             //      << " current time = "
 679             //      << globals->get_time_params()->get_cur_time() << endl;
 680 #endif
 681
 682             // cout << "Found an ils station in range" << endl;
 683             // cout << " id = " << ils.get_locident() << endl;
 684         }
 685     } else if ( current_navlist->query( lon, lat, elev, nav1_freq, &nav ) ) {
 686         nav1_ident = nav.get_ident();
 687         nav1_valid = true;
 688         if ( last_nav1_ident != nav1_ident || !last_nav1_vor ) {
 689             last_nav1_ident = nav1_ident;
 690             last_nav1_vor = true;
 691             nav1_trans_ident = nav.get_trans_ident();
 692             nav1_loc = false;
 693             nav1_has_dme = nav.get_has_dme();
 694             nav1_has_gs = false;
 695             nav1_loclon = nav.get_lon();
 696             nav1_loclat = nav.get_lat();
 697             nav1_elev = nav.get_elev();
 698             nav1_magvar = nav.get_magvar();
 699             nav1_range = nav.get_range();
 700             nav1_effective_range = adjustNavRange(nav1_elev, elev, nav1_range);
 701             nav1_target_gs = 0.0;
 702             nav1_radial = nav1_sel_radial;
 703             nav1_x = nav1_dme_x = nav.get_x();
 704             nav1_y = nav1_dme_y = nav.get_y();
 705             nav1_z = nav1_dme_z = nav.get_z();
 706
 707 #ifdef ENABLE_AUDIO_SUPPORT
 708             if ( globals->get_soundmgr()->exists( "nav1-vor-ident" ) ) {
 709                 globals->get_soundmgr()->remove( "nav1-vor-ident" );
 710             }
 711             FGSimpleSound *sound;
 712             sound = morse.make_ident( nav1_trans_ident, LO_FREQUENCY );
 713             sound->set_volume( 0.3 );
 714             globals->get_soundmgr()->add( sound, "nav1-vor-ident" );
 715
 716             if ( globals->get_soundmgr()->exists( "nav1-dme-ident" ) ) {
 717                 globals->get_soundmgr()->remove( "nav1-dme-ident" );
 718             }
 719             sound = morse.make_ident( nav1_trans_ident, HI_FREQUENCY );
 720             sound->set_volume( 0.3 );
 721             globals->get_soundmgr()->add( sound, "nav1-dme-ident" );
 722
 723             int offset = (int)(sg_random() * 30.0);
 724             nav1_play_count = offset / 4;
 725             nav1_last_time = globals->get_time_params()->get_cur_time() -
 726                 offset;
 727             // cout << "offset = " << offset << " play_count = "
 728             //      << nav1_play_count << " nav1_last_time = "
 729             //      << nav1_last_time << " current time = "
 730             //      << globals->get_time_params()->get_cur_time() << endl;
 731 #endif
 732
 733             // cout << "Found a vor station in range" << endl;
 734             // cout << " id = " << nav.get_ident() << endl;
 735         }
 736     } else {
 737         nav1_valid = false;
 738         nav1_ident = "";
 739         nav1_radial = 0;
 740         nav1_dme_dist = 0;
 741         nav1_trans_ident = "";
 742         last_nav1_ident = "";
 743 #ifdef ENABLE_AUDIO_SUPPORT
 744         globals->get_soundmgr()->remove( "nav1-vor-ident" );
 745         globals->get_soundmgr()->remove( "nav1-dme-ident" );
 746 #endif
 747         // cout << "not picking up vor1. :-(" << endl;
 748     }
 749
 750     if ( current_ilslist->query( lon, lat, elev, nav2_freq, &ils ) ) {
 751         nav2_ident = ils.get_locident();
 752         nav2_valid = true;
 753         if ( last_nav2_ident != nav2_ident || last_nav2_vor ) {
 754             last_nav2_ident = nav2_ident;
 755             last_nav2_vor = false;
 756             nav2_trans_ident = ils.get_trans_ident();
 757             nav2_loc = true;
 758             nav2_has_dme = ils.get_has_dme();
 759             nav2_has_gs = ils.get_has_gs();
 760
 761             nav2_loclon = ils.get_loclon();
 762             nav2_loclat = ils.get_loclat();
 763             nav2_elev = ils.get_gselev();
 764             nav2_magvar = 0;
 765             nav2_range = FG_ILS_DEFAULT_RANGE;
 766             nav2_effective_range = nav2_range;
 767             nav2_target_gs = ils.get_gsangle();
 768             nav2_radial = ils.get_locheading();
 769             while ( nav2_radial <   0.0 ) { nav2_radial += 360.0; }
 770             while ( nav2_radial > 360.0 ) { nav2_radial -= 360.0; }
 771             nav2_x = ils.get_x();
 772             nav2_y = ils.get_y();
 773             nav2_z = ils.get_z();
 774             nav2_gs_x = ils.get_gs_x();
 775             nav2_gs_y = ils.get_gs_y();
 776             nav2_gs_z = ils.get_gs_z();
 777             nav2_dme_x = ils.get_dme_x();
 778             nav2_dme_y = ils.get_dme_y();
 779             nav2_dme_z = ils.get_dme_z();
 780
 781 #ifdef ENABLE_AUDIO_SUPPORT
 782             if ( globals->get_soundmgr()->exists( "nav2-vor-ident" ) ) {
 783                 globals->get_soundmgr()->remove( "nav2-vor-ident" );
 784             }
 785             FGSimpleSound *sound;
 786             sound = morse.make_ident( nav2_trans_ident, LO_FREQUENCY );
 787             sound->set_volume( 0.3 );
 788             globals->get_soundmgr()->add( sound, "nav2-vor-ident" );
 789
 790             if ( globals->get_soundmgr()->exists( "nav2-dme-ident" ) ) {
 791                 globals->get_soundmgr()->remove( "nav2-dme-ident" );
 792             }
 793             sound = morse.make_ident( nav2_trans_ident, HI_FREQUENCY );
 794             sound->set_volume( 0.3 );
 795             globals->get_soundmgr()->add( sound, "nav2-dme-ident" );
 796
 797             int offset = (int)(sg_random() * 30.0);
 798             nav2_play_count = offset / 4;
 799             nav2_last_time = globals->get_time_params()->get_cur_time() -
 800                 offset;
 801             // cout << "offset = " << offset << " play_count = "
 802             //      << nav2_play_count << " nav2_last_time = "
 803             //      << nav2_last_time << " current time = "
 804             //      << globals->get_time_params()->get_cur_time() << endl;
 805 #endif
 806
 807             // cout << "Found an ils station in range" << endl;
 808             // cout << " id = " << ils.get_locident() << endl;
 809         }
 810     } else if ( current_navlist->query( lon, lat, elev, nav2_freq, &nav ) ) {
 811         nav2_ident = nav.get_ident();
 812         nav2_valid = true;
 813         if ( last_nav2_ident != nav2_ident || !last_nav2_vor ) {
 814             last_nav2_ident = nav2_ident;
 815             last_nav2_vor = true;
 816             nav2_trans_ident = nav.get_trans_ident();
 817             nav2_loc = false;
 818             nav2_has_dme = nav.get_has_dme();
 819             nav2_has_dme = false;
 820             nav2_loclon = nav.get_lon();
 821             nav2_loclat = nav.get_lat();
 822             nav2_elev = nav.get_elev();
 823             nav2_magvar = nav.get_magvar();
 824             nav2_range = nav.get_range();
 825             nav2_effective_range = adjustNavRange(nav2_elev, elev, nav2_range);
 826             nav2_target_gs = 0.0;
 827             nav2_radial = nav2_sel_radial;
 828             nav2_x = nav2_dme_x = nav.get_x();
 829             nav2_y = nav2_dme_y = nav.get_y();
 830             nav2_z = nav2_dme_z = nav.get_z();
 831
 832 #ifdef ENABLE_AUDIO_SUPPORT
 833             if ( globals->get_soundmgr()->exists( "nav2-vor-ident" ) ) {
 834                 globals->get_soundmgr()->remove( "nav2-vor-ident" );
 835             }
 836             FGSimpleSound *sound;
 837             sound = morse.make_ident( nav2_trans_ident, LO_FREQUENCY );
 838             sound->set_volume( 0.3 );
 839             globals->get_soundmgr()->add( sound, "nav2-vor-ident" );
 840
 841             if ( globals->get_soundmgr()->exists( "nav2-dme-ident" ) ) {
 842                 globals->get_soundmgr()->remove( "nav2-dme-ident" );
 843             }
 844             sound = morse.make_ident( nav2_trans_ident, HI_FREQUENCY );
 845             sound->set_volume( 0.3 );
 846             globals->get_soundmgr()->add( sound, "nav2-dme-ident" );
 847
 848             int offset = (int)(sg_random() * 30.0);
 849             nav2_play_count = offset / 4;
 850             nav2_last_time = globals->get_time_params()->get_cur_time() -
 851                 offset;
 852             // cout << "offset = " << offset << " play_count = "
 853             //      << nav2_play_count << " nav2_last_time = "
 854             //      << nav2_last_time << " current time = "
 855             //      << globals->get_time_params()->get_cur_time() << endl;
 856 #endif
 857
 858             // cout << "Found a vor station in range" << endl;
 859             // cout << " id = " << nav.get_ident() << endl;
 860         }
 861     } else {
 862         nav2_valid = false;
 863         nav2_ident = "";
 864         nav2_radial = 0;
 865         nav2_dme_dist = 0;
 866         nav2_trans_ident = "";
 867         last_nav2_ident = "";
 868 #ifdef ENABLE_AUDIO_SUPPORT
 869         globals->get_soundmgr()->remove( "nav2-vor-ident" );
 870         globals->get_soundmgr()->remove( "nav2-dme-ident" );
 871 #endif
 872         // cout << "not picking up vor1. :-(" << endl;
 873     }
 874
 875     FGMkrBeacon::fgMkrBeacType beacon_type
 876         = current_beacons->query( lon * SGD_RADIANS_TO_DEGREES,
 877                                   lat * SGD_RADIANS_TO_DEGREES, elev );
 878
 879     outer_marker = middle_marker = inner_marker = false;
 880
 881     if ( beacon_type == FGMkrBeacon::OUTER ) {
 882         outer_marker = true;
 883         // cout << "OUTER MARKER" << endl;
 884 #ifdef ENABLE_AUDIO_SUPPORT
 885         if ( last_beacon != FGMkrBeacon::OUTER ) {
 886             if ( ! globals->get_soundmgr()->exists( "outer-marker" ) ) {
 887                 FGSimpleSound *sound = beacon.get_outer();
 888                 sound->set_volume( 0.3 );
 889                 globals->get_soundmgr()->add( sound, "outer-marker" );
 890             }
 891             if ( !globals->get_soundmgr()->is_playing("outer-marker") ) {
 892                 globals->get_soundmgr()->play_looped( "outer-marker" );
 893             }
 894         }
 895 #endif
 896     } else if ( beacon_type == FGMkrBeacon::MIDDLE ) {
 897         middle_marker = true;
 898         // cout << "MIDDLE MARKER" << endl;
 899 #ifdef ENABLE_AUDIO_SUPPORT
 900         if ( last_beacon != FGMkrBeacon::MIDDLE ) {
 901             if ( ! globals->get_soundmgr()->exists( "middle-marker" ) ) {
 902                 FGSimpleSound *sound = beacon.get_middle();
 903                 sound->set_volume( 0.3 );
 904                 globals->get_soundmgr()->add( sound, "middle-marker" );
 905             }
 906             if ( !globals->get_soundmgr()->is_playing("middle-marker") ) {
 907                 globals->get_soundmgr()->play_looped( "middle-marker" );
 908             }
 909         }
 910 #endif
 911     } else if ( beacon_type == FGMkrBeacon::INNER ) {
 912         inner_marker = true;
 913         // cout << "INNER MARKER" << endl;
 914 #ifdef ENABLE_AUDIO_SUPPORT
 915         if ( last_beacon != FGMkrBeacon::INNER ) {
 916             if ( ! globals->get_soundmgr()->exists( "inner-marker" ) ) {
 917                 FGSimpleSound *sound = beacon.get_inner();
 918                 sound->set_volume( 0.3 );
 919                 globals->get_soundmgr()->add( sound, "inner-marker" );
 920             }
 921             if ( !globals->get_soundmgr()->is_playing("inner-marker") ) {
 922                 globals->get_soundmgr()->play_looped( "inner-marker" );
 923             }
 924         }
 925 #endif
 926     } else {
 927         // cout << "no marker" << endl;
 928 #ifdef ENABLE_AUDIO_SUPPORT
 929         globals->get_soundmgr()->stop( "outer-marker" );
 930         globals->get_soundmgr()->stop( "middle-marker" );
 931         globals->get_soundmgr()->stop( "inner-marker" );
 932 #endif
 933     }
 934     last_beacon = beacon_type;
 935
 936     // adf
 937     if ( current_navlist->query( lon, lat, elev, adf_freq, &nav ) ) {
 938         char freq[128];
 939 #if defined( _MSC_VER )
 940         _snprintf( freq, 10, "%.0f", adf_freq );
 941 #else
 942         snprintf( freq, 10, "%.0f", adf_freq );
 943 #endif
 944         adf_ident = freq;
 945         adf_ident += nav.get_ident();
 946         // cout << "adf ident = " << adf_ident << endl;
 947         adf_valid = true;
 948         if ( last_adf_ident != adf_ident ) {
 949             last_adf_ident = adf_ident;
 950
 951             adf_trans_ident = nav.get_trans_ident();
 952             adf_lon = nav.get_lon();
 953             adf_lat = nav.get_lat();
 954             adf_elev = nav.get_elev();
 955             adf_range = nav.get_range();
 956             adf_effective_range = kludgeRange(adf_elev, elev, adf_range);
 957             adf_x = nav.get_x();
 958             adf_y = nav.get_y();
 959             adf_z = nav.get_z();
 960
 961 #ifdef ENABLE_AUDIO_SUPPORT
 962             if ( globals->get_soundmgr()->exists( "adf-ident" ) ) {
 963                 globals->get_soundmgr()->remove( "adf-ident" );
 964             }
 965             FGSimpleSound *sound;
 966             sound = morse.make_ident( adf_trans_ident, LO_FREQUENCY );
 967             sound->set_volume( 0.3 );
 968             globals->get_soundmgr()->add( sound, "adf-ident" );
 969
 970             int offset = (int)(sg_random() * 30.0);
 971             adf_play_count = offset / 4;
 972             adf_last_time = globals->get_time_params()->get_cur_time() -
 973                 offset;
 974             // cout << "offset = " << offset << " play_count = "
 975             //      << adf_play_count << " adf_last_time = "
 976             //      << adf_last_time << " current time = "
 977             //      << globals->get_time_params()->get_cur_time() << endl;
 978 #endif
 979
 980             // cout << "Found an adf station in range" << endl;
 981             // cout << " id = " << nav.get_ident() << endl;
 982         }
 983     } else {
 984         adf_valid = false;
 985         adf_ident = "";
 986         adf_trans_ident = "";
 987 #ifdef ENABLE_AUDIO_SUPPORT
 988         globals->get_soundmgr()->remove( "adf-ident" );
 989 #endif
 990         last_adf_ident = "";
 991         // cout << "not picking up adf. :-(" << endl;
 992     }
 993 }
 994
 995
 996 // return the amount of heading needle deflection, returns a value
 997 // clamped to the range of ( -10 , 10 )
 998 double FGRadioStack::get_nav1_heading_needle_deflection() const {
 999     double r;
1000
1001     if ( nav1_inrange ) {
1002         r = nav1_heading - nav1_radial;
1003         // cout << "Radial = " << nav1_radial
1004         //      << "  Bearing = " << nav1_heading << endl;
1005
1006         while ( r >  180.0 ) { r -= 360.0;}
1007         while ( r < -180.0 ) { r += 360.0;}
1008         if ( fabs(r) > 90.0 ) {
1009             r = ( r<0.0 ? -r-180.0 : -r+180.0 );
1010             if ( nav1_loc ) {
1011                 r = -r;
1012             }
1013         }
1014
1015         // According to Robin Peel, the ILS is 4x more sensitive than a vor
1016         if ( nav1_loc ) { r *= 4.0; }
1017         if ( r < -10.0 ) { r = -10.0; }
1018         if ( r >  10.0 ) { r = 10.0; }
1019     } else {
1020         r = 0.0;
1021     }
1022
1023     return r;
1024 }
1025
1026 // return the amount of heading needle deflection, returns a value
1027 // clamped to the range of ( -10 , 10 )
1028 double FGRadioStack::get_nav2_heading_needle_deflection() const {
1029     double r;
1030
1031     if ( nav2_inrange ) {
1032         r = nav2_heading - nav2_radial;
1033         // cout << "Radial = " << nav2_radial
1034         //      << "  Bearing = " << nav2_heading << endl;
1035
1036         while (r> 180.0) r-=360.0;
1037         while (r<-180.0) r+=360.0;
1038         if ( fabs(r) > 90.0 )
1039             r = ( r<0.0 ? -r-180.0 : -r+180.0 );
1040         // According to Robin Peel, the ILS is 4x more sensitive than a vor
1041         if ( nav2_loc ) r *= 4.0;
1042         if ( r < -10.0 ) r = -10.0;
1043         if ( r > 10.0 ) r = 10.0;
1044     } else {
1045         r = 0.0;
1046     }
1047
1048     return r;
1049 }
1050
1051 // return the amount of glide slope needle deflection (.i.e. the
1052 // number of degrees we are off the glide slope * 5.0
1053 double FGRadioStack::get_nav1_gs_needle_deflection() const {
1054     if ( nav1_inrange && nav1_has_gs ) {
1055         double x = nav1_gs_dist;
1056         double y = (FGBFI::getAltitude() - nav1_elev) * SG_FEET_TO_METER;
1057         double angle = atan2( y, x ) * SGD_RADIANS_TO_DEGREES;
1058         return (nav1_target_gs - angle) * 5.0;
1059     } else {
1060         return 0.0;
1061     }
1062 }
1063
1064
1065 // return the amount of glide slope needle deflection (.i.e. the
1066 // number of degrees we are off the glide slope * 5.0
1067 double FGRadioStack::get_nav2_gs_needle_deflection() const {
1068     if ( nav2_inrange && nav2_has_gs ) {
1069         double x = nav2_gs_dist;
1070         double y = (FGBFI::getAltitude() - nav2_elev) * SG_FEET_TO_METER;
1071         double angle = atan2( y, x ) * SGD_RADIANS_TO_DEGREES;
1072         return (nav2_target_gs - angle) * 5.0;
1073     } else {
1074         return 0.0;
1075     }
1076 }
1077
1078
1079 /**
1080  * Return true if the NAV1 TO flag should be active.
1081  */
1082 bool
1083 FGRadioStack::get_nav1_to_flag () const
1084 {
1085   if (nav1_inrange) {
1086     double offset = fabs(nav1_heading - nav1_radial);
1087     if (nav1_loc)
1088       return true;
1089     else
1090       return (offset <= 90.0 || offset >= 270.0);
1091   } else {
1092     return false;
1093   }
1094 }
1095
1096
1097 /**
1098  * Return true if the NAV1 FROM flag should be active.
1099  */
1100 bool
1101 FGRadioStack::get_nav1_from_flag () const
1102 {
1103   if (nav1_inrange) {
1104     double offset = fabs(nav1_heading - nav1_radial);
1105     if (nav1_loc)
1106       return false;
1107     else
1108       return (offset > 90.0 && offset < 270.0);
1109   } else {
1110     return false;
1111   }
1112 }
1113
1114
1115 /**
1116  * Return true if the NAV2 TO flag should be active.
1117  */
1118 bool
1119 FGRadioStack::get_nav2_to_flag () const
1120 {
1121   if (nav2_inrange) {
1122     double offset = fabs(nav2_heading - nav2_radial);
1123     if (nav2_loc)
1124       return true;
1125     else
1126       return (offset <= 90.0 || offset >= 270.0);
1127   } else {
1128     return false;
1129   }
1130 }
1131
1132
1133 /**
1134  * Return true if the NAV2 FROM flag should be active.
1135  */
1136 bool
1137 FGRadioStack::get_nav2_from_flag () const
1138 {
1139   if (nav2_inrange) {
1140     double offset = fabs(nav2_heading - nav2_radial);
1141     if (nav2_loc)
1142       return false;
1143     else
1144       return (offset > 90.0 && offset < 270.0);
1145   } else {
1146     return false;
1147   }
1148 }
1149