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