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