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