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