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