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/on", this,
 132           &FGRadioStack::get_nav1_on_btn,
 133           &FGRadioStack::set_nav1_on_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/on", this,
 160           &FGRadioStack::get_nav2_on_btn,
 161           &FGRadioStack::set_nav2_on_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/on", this,
 187           &FGRadioStack::get_adf_on_btn,
 188           &FGRadioStack::set_adf_on_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_on_btn && nav1_ident_btn ) {
 367             if ( nav1_last_time <
 368                  globals->get_time_params()->get_cur_time() - 30 ) {
 369                 nav1_last_time = globals->get_time_params()->get_cur_time();
 370                 nav1_play_count = 0;
 371             }
 372             if ( nav1_play_count < 4 ) {
 373                 // play VOR ident
 374                 if ( !globals->get_soundmgr()->is_playing("nav1-vor-ident") ) {
 375                     globals->get_soundmgr()->play_once( "nav1-vor-ident" );
 376                     ++nav1_play_count;
 377                 }
 378             } else if ( nav1_play_count < 5 && nav1_has_dme ) {
 379                 // play DME ident
 380                 if ( !globals->get_soundmgr()->is_playing("nav1-vor-ident") &&
 381                      !globals->get_soundmgr()->is_playing("nav1-dme-ident") ) {
 382                     globals->get_soundmgr()->play_once( "nav1-dme-ident" );
 383                     ++nav1_play_count;
 384                 }
 385             }
 386         } else {
 387             globals->get_soundmgr()->stop( "nav1-vor-ident" );
 388             globals->get_soundmgr()->stop( "nav1-dme-ident" );
 389         }
 390     }
 391
 392     if ( nav2_valid ) {
 393         station = Point3D( nav2_x, nav2_y, nav2_z );
 394         nav2_loc_dist = aircraft.distance3D( station );
 395
 396         if ( nav2_has_dme ) {
 397             // staightline distance
 398             station = Point3D( nav2_dme_x, nav2_dme_y, nav2_dme_z );
 399             nav2_dme_dist = aircraft.distance3D( station );
 400         } else {
 401             nav2_dme_dist = 0.0;
 402         }
 403
 404         if ( nav2_has_gs ) {
 405             station = Point3D( nav2_gs_x, nav2_gs_y, nav2_gs_z );
 406             nav2_gs_dist = aircraft.distance3D( station );
 407         } else {
 408             nav2_gs_dist = 0.0;
 409         }
 410
 411         // wgs84 heading
 412         geo_inverse_wgs_84( elev, lat * RAD_TO_DEG, lon * RAD_TO_DEG,
 413                             nav2_loclat, nav2_loclon,
 414                             &az1, &az2, &s );
 415         nav2_heading = az1 - nav2_magvar;
 416         // cout << " heading = " << nav2_heading
 417         //      << " dist = " << nav2_dist << endl;
 418
 419         if ( nav2_loc ) {
 420             double offset = nav2_heading - nav2_radial;
 421             while ( offset < -180.0 ) { offset += 360.0; }
 422             while ( offset > 180.0 ) { offset -= 360.0; }
 423             // cout << "ils offset = " << offset << endl;
 424             nav2_effective_range = adjustILSRange(nav2_elev, elev, offset,
 425                                                   nav2_loc_dist * METER_TO_NM );
 426         } else {
 427             nav2_effective_range = adjustNavRange(nav2_elev, elev, nav2_range);
 428         }
 429         // cout << "nav2 range = " << nav2_effective_range
 430         //      << " (" << nav2_range << ")" << endl;
 431
 432         if ( nav2_loc_dist < nav2_effective_range * NM_TO_METER ) {
 433             nav2_inrange = true;
 434         } else if ( nav2_loc_dist < 2 * nav2_effective_range * NM_TO_METER ) {
 435             nav2_inrange = sg_random() <
 436                 ( 2 * nav2_effective_range * NM_TO_METER - nav2_loc_dist ) /
 437                 (nav2_effective_range * NM_TO_METER);
 438         } else {
 439             nav2_inrange = false;
 440         }
 441
 442         if ( !nav2_loc ) {
 443             nav2_radial = nav2_sel_radial;
 444         }
 445     } else {
 446         nav2_inrange = false;
 447         nav2_dme_dist = 0.0;
 448         // cout << "not picking up vor. :-(" << endl;
 449     }
 450
 451     if ( nav2_valid && nav2_inrange ) {
 452         // play station ident via audio system if on + ident,
 453         // otherwise turn it off
 454         if ( nav2_on_btn && nav2_ident_btn ) {
 455             if ( nav2_last_time <
 456                  globals->get_time_params()->get_cur_time() - 30 ) {
 457                 nav2_last_time = globals->get_time_params()->get_cur_time();
 458                 nav2_play_count = 0;
 459             }
 460             if ( nav2_play_count < 4 ) {
 461                 // play VOR ident
 462                 if ( !globals->get_soundmgr()->is_playing("nav2-vor-ident") ) {
 463                     globals->get_soundmgr()->play_once( "nav2-vor-ident" );
 464                     ++nav2_play_count;
 465                 }
 466             } else if ( nav2_play_count < 5 && nav2_has_dme ) {
 467                 // play DME ident
 468                 if ( !globals->get_soundmgr()->is_playing("nav2-vor-ident") &&
 469                      !globals->get_soundmgr()->is_playing("nav2-dme-ident") ) {
 470                     globals->get_soundmgr()->play_once( "nav2-dme-ident" );
 471                     ++nav2_play_count;
 472                 }
 473             }
 474         } else {
 475             globals->get_soundmgr()->stop( "nav2-vor-ident" );
 476             globals->get_soundmgr()->stop( "nav2-dme-ident" );
 477         }
 478     }
 479
 480     // adf
 481     if ( adf_valid ) {
 482         // staightline distance
 483         station = Point3D( adf_x, adf_y, adf_z );
 484         adf_dist = aircraft.distance3D( station );
 485
 486         // wgs84 heading
 487         geo_inverse_wgs_84( elev, lat * RAD_TO_DEG, lon * RAD_TO_DEG,
 488                             adf_lat, adf_lon,
 489                             &az1, &az2, &s );
 490         adf_heading = az1;
 491         // cout << " heading = " << nav2_heading
 492         //      << " dist = " << nav2_dist << endl;
 493
 494         adf_effective_range = kludgeRange(adf_elev, elev, adf_range);
 495         if ( adf_dist < adf_effective_range * NM_TO_METER ) {
 496             adf_inrange = true;
 497         } else if ( adf_dist < 2 * adf_effective_range * NM_TO_METER ) {
 498             adf_inrange = sg_random() <
 499                 ( 2 * adf_effective_range * NM_TO_METER - adf_dist ) /
 500                 (adf_effective_range * NM_TO_METER);
 501         } else {
 502             adf_inrange = false;
 503         }
 504     } else {
 505         adf_inrange = false;
 506     }
 507
 508     if ( adf_valid && adf_inrange ) {
 509         // play station ident via audio system if on + ident,
 510         // otherwise turn it off
 511         if ( adf_on_btn && adf_ident_btn ) {
 512             if ( adf_last_time <
 513                  globals->get_time_params()->get_cur_time() - 30 ) {
 514                 adf_last_time = globals->get_time_params()->get_cur_time();
 515                 adf_play_count = 0;
 516             }
 517             if ( adf_play_count < 4 ) {
 518                 // play ADF ident
 519                 if ( !globals->get_soundmgr()->is_playing("adf-ident") ) {
 520                     globals->get_soundmgr()->play_once( "adf-ident" );
 521                     ++adf_play_count;
 522                 }
 523             }
 524         } else {
 525             globals->get_soundmgr()->stop( "adf-ident" );
 526         }
 527     }
 528 }
 529
 530
 531 // Update current nav/adf radio stations based on current postition
 532 void FGRadioStack::search()
 533 {
 534     double lon = longitudeVal->getDoubleValue() * DEG_TO_RAD;
 535     double lat = latitudeVal->getDoubleValue() * DEG_TO_RAD;
 536     double elev = altitudeVal->getDoubleValue() * FEET_TO_METER;
 537
 538     // nav1
 539     FGILS ils;
 540     FGNav nav;
 541
 542     static string last_nav1_ident = "";
 543     static string last_nav2_ident = "";
 544     static string last_adf_ident = "";
 545     static bool last_nav1_vor = false;
 546     static bool last_nav2_vor = false;
 547     if ( current_ilslist->query( lon, lat, elev, nav1_freq, &ils ) ) {
 548         nav1_ident = ils.get_locident();
 549         nav1_valid = true;
 550         if ( last_nav1_ident != nav1_ident || last_nav1_vor ) {
 551             nav1_trans_ident = ils.get_trans_ident();
 552             last_nav1_ident = nav1_ident;
 553             last_nav1_vor = false;
 554             nav1_loc = true;
 555             nav1_has_dme = ils.get_has_dme();
 556             nav1_has_gs = ils.get_has_gs();
 557
 558             nav1_loclon = ils.get_loclon();
 559             nav1_loclat = ils.get_loclat();
 560             nav1_gslon = ils.get_gslon();
 561             nav1_gslat = ils.get_gslat();
 562             nav1_dmelon = ils.get_dmelon();
 563             nav1_dmelat = ils.get_dmelat();
 564             nav1_elev = ils.get_gselev();
 565             nav1_magvar = 0;
 566             nav1_range = FG_ILS_DEFAULT_RANGE;
 567             nav1_effective_range = nav1_range;
 568             nav1_target_gs = ils.get_gsangle();
 569             nav1_radial = ils.get_locheading();
 570             while ( nav1_radial <   0.0 ) { nav1_radial += 360.0; }
 571             while ( nav1_radial > 360.0 ) { nav1_radial -= 360.0; }
 572             nav1_x = ils.get_x();
 573             nav1_y = ils.get_y();
 574             nav1_z = ils.get_z();
 575             nav1_gs_x = ils.get_gs_x();
 576             nav1_gs_y = ils.get_gs_y();
 577             nav1_gs_z = ils.get_gs_z();
 578             nav1_dme_x = ils.get_dme_x();
 579             nav1_dme_y = ils.get_dme_y();
 580             nav1_dme_z = ils.get_dme_z();
 581
 582             if ( globals->get_soundmgr()->exists( "nav1-vor-ident" ) ) {
 583                 globals->get_soundmgr()->remove( "nav1-vor-ident" );
 584             }
 585             FGSimpleSound *sound;
 586             sound = morse.make_ident( nav1_trans_ident, LO_FREQUENCY );
 587             sound->set_volume( 0.3 );
 588             globals->get_soundmgr()->add( sound, "nav1-vor-ident" );
 589
 590             if ( globals->get_soundmgr()->exists( "nav1-dme-ident" ) ) {
 591                 globals->get_soundmgr()->remove( "nav1-dme-ident" );
 592             }
 593             sound = morse.make_ident( nav1_trans_ident, HI_FREQUENCY );
 594             sound->set_volume( 0.3 );
 595             globals->get_soundmgr()->add( sound, "nav1-dme-ident" );
 596
 597             int offset = (int)(sg_random() * 30.0);
 598             nav1_play_count = offset / 4;
 599             nav1_last_time = globals->get_time_params()->get_cur_time() -
 600                 offset;
 601             // cout << "offset = " << offset << " play_count = "
 602             //      << nav1_play_count
 603             //      << " nav1_last_time = " << nav1_last_time
 604             //      << " current time = "
 605             //      << globals->get_time_params()->get_cur_time() << endl;
 606
 607             // cout << "Found an ils station in range" << endl;
 608             // cout << " id = " << ils.get_locident() << endl;
 609         }
 610     } else if ( current_navlist->query( lon, lat, elev, nav1_freq, &nav ) ) {
 611         nav1_ident = nav.get_ident();
 612         nav1_valid = true;
 613         if ( last_nav1_ident != nav1_ident || !last_nav1_vor ) {
 614             last_nav1_ident = nav1_ident;
 615             last_nav1_vor = true;
 616             nav1_trans_ident = nav.get_trans_ident();
 617             nav1_loc = false;
 618             nav1_has_dme = nav.get_has_dme();
 619             nav1_has_gs = false;
 620             nav1_loclon = nav.get_lon();
 621             nav1_loclat = nav.get_lat();
 622             nav1_elev = nav.get_elev();
 623             nav1_magvar = nav.get_magvar();
 624             nav1_range = nav.get_range();
 625             nav1_effective_range = adjustNavRange(nav1_elev, elev, nav1_range);
 626             nav1_target_gs = 0.0;
 627             nav1_radial = nav1_sel_radial;
 628             nav1_x = nav1_dme_x = nav.get_x();
 629             nav1_y = nav1_dme_y = nav.get_y();
 630             nav1_z = nav1_dme_z = nav.get_z();
 631
 632             if ( globals->get_soundmgr()->exists( "nav1-vor-ident" ) ) {
 633                 globals->get_soundmgr()->remove( "nav1-vor-ident" );
 634             }
 635             FGSimpleSound *sound;
 636             sound = morse.make_ident( nav1_trans_ident, LO_FREQUENCY );
 637             sound->set_volume( 0.3 );
 638             globals->get_soundmgr()->add( sound, "nav1-vor-ident" );
 639
 640             if ( globals->get_soundmgr()->exists( "nav1-dme-ident" ) ) {
 641                 globals->get_soundmgr()->remove( "nav1-dme-ident" );
 642             }
 643             sound = morse.make_ident( nav1_trans_ident, HI_FREQUENCY );
 644             sound->set_volume( 0.3 );
 645             globals->get_soundmgr()->add( sound, "nav1-dme-ident" );
 646
 647             int offset = (int)(sg_random() * 30.0);
 648             nav1_play_count = offset / 4;
 649             nav1_last_time = globals->get_time_params()->get_cur_time() -
 650                 offset;
 651             // cout << "offset = " << offset << " play_count = "
 652             //      << nav1_play_count << " nav1_last_time = "
 653             //      << nav1_last_time << " current time = "
 654             //      << globals->get_time_params()->get_cur_time() << endl;
 655
 656             // cout << "Found a vor station in range" << endl;
 657             // cout << " id = " << nav.get_ident() << endl;
 658         }
 659     } else {
 660         nav1_valid = false;
 661         nav1_ident = "";
 662         nav1_radial = 0;
 663         nav1_dme_dist = 0;
 664         nav1_trans_ident = "";
 665         last_nav1_ident = "";
 666         globals->get_soundmgr()->remove( "nav1-vor-ident" );
 667         globals->get_soundmgr()->remove( "nav1-dme-ident" );
 668         // cout << "not picking up vor1. :-(" << endl;
 669     }
 670
 671     if ( current_ilslist->query( lon, lat, elev, nav2_freq, &ils ) ) {
 672         nav2_ident = ils.get_locident();
 673         nav2_valid = true;
 674         if ( last_nav2_ident != nav2_ident || last_nav2_vor ) {
 675             last_nav2_ident = nav2_ident;
 676             last_nav2_vor = false;
 677             nav2_trans_ident = ils.get_trans_ident();
 678             nav2_loc = true;
 679             nav2_has_dme = ils.get_has_dme();
 680             nav2_has_gs = ils.get_has_gs();
 681
 682             nav2_loclon = ils.get_loclon();
 683             nav2_loclat = ils.get_loclat();
 684             nav2_elev = ils.get_gselev();
 685             nav2_magvar = 0;
 686             nav2_range = FG_ILS_DEFAULT_RANGE;
 687             nav2_effective_range = nav2_range;
 688             nav2_target_gs = ils.get_gsangle();
 689             nav2_radial = ils.get_locheading();
 690             while ( nav2_radial <   0.0 ) { nav2_radial += 360.0; }
 691             while ( nav2_radial > 360.0 ) { nav2_radial -= 360.0; }
 692             nav2_x = ils.get_x();
 693             nav2_y = ils.get_y();
 694             nav2_z = ils.get_z();
 695             nav2_gs_x = ils.get_gs_x();
 696             nav2_gs_y = ils.get_gs_y();
 697             nav2_gs_z = ils.get_gs_z();
 698             nav2_dme_x = ils.get_dme_x();
 699             nav2_dme_y = ils.get_dme_y();
 700             nav2_dme_z = ils.get_dme_z();
 701
 702             if ( globals->get_soundmgr()->exists( "nav2-vor-ident" ) ) {
 703                 globals->get_soundmgr()->remove( "nav2-vor-ident" );
 704             }
 705             FGSimpleSound *sound;
 706             sound = morse.make_ident( nav2_trans_ident, LO_FREQUENCY );
 707             sound->set_volume( 0.3 );
 708             globals->get_soundmgr()->add( sound, "nav2-vor-ident" );
 709
 710             if ( globals->get_soundmgr()->exists( "nav2-dme-ident" ) ) {
 711                 globals->get_soundmgr()->remove( "nav2-dme-ident" );
 712             }
 713             sound = morse.make_ident( nav2_trans_ident, HI_FREQUENCY );
 714             sound->set_volume( 0.3 );
 715             globals->get_soundmgr()->add( sound, "nav2-dme-ident" );
 716
 717             int offset = (int)(sg_random() * 30.0);
 718             nav2_play_count = offset / 4;
 719             nav2_last_time = globals->get_time_params()->get_cur_time() -
 720                 offset;
 721             // cout << "offset = " << offset << " play_count = "
 722             //      << nav2_play_count << " nav2_last_time = "
 723             //      << nav2_last_time << " current time = "
 724             //      << globals->get_time_params()->get_cur_time() << endl;
 725
 726             // cout << "Found an ils station in range" << endl;
 727             // cout << " id = " << ils.get_locident() << endl;
 728         }
 729     } else if ( current_navlist->query( lon, lat, elev, nav2_freq, &nav ) ) {
 730         nav2_ident = nav.get_ident();
 731         nav2_valid = true;
 732         if ( last_nav2_ident != nav2_ident || !last_nav2_vor ) {
 733             last_nav2_ident = nav2_ident;
 734             last_nav2_vor = true;
 735             nav2_trans_ident = nav.get_trans_ident();
 736             nav2_loc = false;
 737             nav2_has_dme = nav.get_has_dme();
 738             nav2_has_dme = false;
 739             nav2_loclon = nav.get_lon();
 740             nav2_loclat = nav.get_lat();
 741             nav2_elev = nav.get_elev();
 742             nav2_magvar = nav.get_magvar();
 743             nav2_range = nav.get_range();
 744             nav2_effective_range = adjustNavRange(nav2_elev, elev, nav2_range);
 745             nav2_target_gs = 0.0;
 746             nav2_radial = nav2_sel_radial;
 747             nav2_x = nav2_dme_x = nav.get_x();
 748             nav2_y = nav2_dme_y = nav.get_y();
 749             nav2_z = nav2_dme_z = nav.get_z();
 750
 751             if ( globals->get_soundmgr()->exists( "nav2-vor-ident" ) ) {
 752                 globals->get_soundmgr()->remove( "nav2-vor-ident" );
 753             }
 754             FGSimpleSound *sound;
 755             sound = morse.make_ident( nav2_trans_ident, LO_FREQUENCY );
 756             sound->set_volume( 0.3 );
 757             globals->get_soundmgr()->add( sound, "nav2-vor-ident" );
 758
 759             if ( globals->get_soundmgr()->exists( "nav2-dme-ident" ) ) {
 760                 globals->get_soundmgr()->remove( "nav2-dme-ident" );
 761             }
 762             sound = morse.make_ident( nav2_trans_ident, HI_FREQUENCY );
 763             sound->set_volume( 0.3 );
 764             globals->get_soundmgr()->add( sound, "nav2-dme-ident" );
 765
 766             int offset = (int)(sg_random() * 30.0);
 767             nav2_play_count = offset / 4;
 768             nav2_last_time = globals->get_time_params()->get_cur_time() -
 769                 offset;
 770             // cout << "offset = " << offset << " play_count = "
 771             //      << nav2_play_count << " nav2_last_time = "
 772             //      << nav2_last_time << " current time = "
 773             //      << globals->get_time_params()->get_cur_time() << endl;
 774
 775             // cout << "Found a vor station in range" << endl;
 776             // cout << " id = " << nav.get_ident() << endl;
 777         }
 778     } else {
 779         nav2_valid = false;
 780         nav2_ident = "";
 781         nav2_radial = 0;
 782         nav2_dme_dist = 0;
 783         nav2_trans_ident = "";
 784         last_nav2_ident = "";
 785         globals->get_soundmgr()->remove( "nav2-vor-ident" );
 786         globals->get_soundmgr()->remove( "nav2-dme-ident" );
 787         // cout << "not picking up vor1. :-(" << endl;
 788     }
 789
 790     // adf
 791     if ( current_navlist->query( lon, lat, elev, adf_freq, &nav ) ) {
 792         char freq[128];
 793         snprintf( freq, 10, "%.0f", adf_freq );
 794         adf_ident = freq;
 795         adf_ident += nav.get_ident();
 796         // cout << "adf ident = " << adf_ident << endl;
 797         adf_valid = true;
 798         if ( last_adf_ident != adf_ident ) {
 799             last_adf_ident = adf_ident;
 800
 801             adf_trans_ident = nav.get_trans_ident();
 802             adf_lon = nav.get_lon();
 803             adf_lat = nav.get_lat();
 804             adf_elev = nav.get_elev();
 805             adf_range = nav.get_range();
 806             adf_effective_range = kludgeRange(adf_elev, elev, adf_range);
 807             adf_x = nav.get_x();
 808             adf_y = nav.get_y();
 809             adf_z = nav.get_z();
 810
 811             if ( globals->get_soundmgr()->exists( "adf-ident" ) ) {
 812                 globals->get_soundmgr()->remove( "adf-ident" );
 813             }
 814             FGSimpleSound *sound;
 815             sound = morse.make_ident( adf_trans_ident, LO_FREQUENCY );
 816             sound->set_volume( 0.3 );
 817             globals->get_soundmgr()->add( sound, "adf-ident" );
 818
 819             int offset = (int)(sg_random() * 30.0);
 820             adf_play_count = offset / 4;
 821             adf_last_time = globals->get_time_params()->get_cur_time() -
 822                 offset;
 823             // cout << "offset = " << offset << " play_count = "
 824             //      << adf_play_count << " adf_last_time = "
 825             //      << adf_last_time << " current time = "
 826             //      << globals->get_time_params()->get_cur_time() << endl;
 827
 828             // cout << "Found an adf station in range" << endl;
 829             // cout << " id = " << nav.get_ident() << endl;
 830         }
 831     } else {
 832         adf_valid = false;
 833         adf_ident = "";
 834         adf_trans_ident = "";
 835         globals->get_soundmgr()->remove( "adf-ident" );
 836         last_adf_ident = "";
 837         // cout << "not picking up adf. :-(" << endl;
 838     }
 839 }
 840
 841
 842 // return the amount of heading needle deflection, returns a value
 843 // clamped to the range of ( -10 , 10 )
 844 double FGRadioStack::get_nav1_heading_needle_deflection() const {
 845     double r;
 846
 847     if ( nav1_inrange ) {
 848         r = nav1_heading - nav1_radial;
 849         // cout << "Radial = " << nav1_radial
 850         //      << "  Bearing = " << nav1_heading << endl;
 851
 852         while ( r >  180.0 ) { r -= 360.0;}
 853         while ( r < -180.0 ) { r += 360.0;}
 854         if ( fabs(r) > 90.0 ) {
 855             r = ( r<0.0 ? -r-180.0 : -r+180.0 );
 856             if ( nav1_loc ) {
 857                 r = -r;
 858             }
 859         }
 860
 861         // According to Robin Peel, the ILS is 4x more sensitive than a vor
 862         if ( nav1_loc ) { r *= 4.0; }
 863         if ( r < -10.0 ) { r = -10.0; }
 864         if ( r >  10.0 ) { r = 10.0; }
 865     } else {
 866         r = 0.0;
 867     }
 868
 869     return r;
 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_nav2_heading_needle_deflection() const {
 875     double r;
 876
 877     if ( nav2_inrange ) {
 878         r = nav2_heading - nav2_radial;
 879         // cout << "Radial = " << nav2_radial
 880         //      << "  Bearing = " << nav2_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         // According to Robin Peel, the ILS is 4x more sensitive than a vor
 887         if ( nav2_loc ) r *= 4.0;
 888         if ( r < -10.0 ) r = -10.0;
 889         if ( r > 10.0 ) r = 10.0;
 890     } else {
 891         r = 0.0;
 892     }
 893
 894     return r;
 895 }
 896
 897 // return the amount of glide slope needle deflection (.i.e. the
 898 // number of degrees we are off the glide slope * 5.0
 899 double FGRadioStack::get_nav1_gs_needle_deflection() const {
 900     if ( nav1_inrange && nav1_has_gs ) {
 901         double x = nav1_gs_dist;
 902         double y = (FGBFI::getAltitude() - nav1_elev) * FEET_TO_METER;
 903         double angle = atan2( y, x ) * RAD_TO_DEG;
 904         return (nav1_target_gs - angle) * 5.0;
 905     } else {
 906         return 0.0;
 907     }
 908 }
 909
 910
 911 // return the amount of glide slope needle deflection (.i.e. the
 912 // number of degrees we are off the glide slope * 5.0
 913 double FGRadioStack::get_nav2_gs_needle_deflection() const {
 914     if ( nav2_inrange && nav2_has_gs ) {
 915         double x = nav2_gs_dist;
 916         double y = (FGBFI::getAltitude() - nav2_elev) * FEET_TO_METER;
 917         double angle = atan2( y, x ) * RAD_TO_DEG;
 918         return (nav2_target_gs - angle) * 5.0;
 919     } else {
 920         return 0.0;
 921     }
 922 }
 923
 924
 925 /**
 926  * Return true if the NAV1 TO flag should be active.
 927  */
 928 bool
 929 FGRadioStack::get_nav1_to_flag () const
 930 {
 931   if (nav1_inrange) {
 932     double offset = fabs(nav1_heading - nav1_radial);
 933     if (nav1_loc)
 934       return true;
 935     else
 936       return (offset <= 90.0 || offset >= 270.0);
 937   } else {
 938     return false;
 939   }
 940 }
 941
 942
 943 /**
 944  * Return true if the NAV1 FROM flag should be active.
 945  */
 946 bool
 947 FGRadioStack::get_nav1_from_flag () const
 948 {
 949   if (nav1_inrange) {
 950     double offset = fabs(nav1_heading - nav1_radial);
 951     if (nav1_loc)
 952       return false;
 953     else
 954       return (offset > 90.0 && offset < 270.0);
 955   } else {
 956     return false;
 957   }
 958 }
 959
 960
 961 /**
 962  * Return true if the NAV2 TO flag should be active.
 963  */
 964 bool
 965 FGRadioStack::get_nav2_to_flag () const
 966 {
 967   if (nav2_inrange) {
 968     double offset = fabs(nav2_heading - nav2_radial);
 969     if (nav2_loc)
 970       return true;
 971     else
 972       return (offset <= 90.0 || offset >= 270.0);
 973   } else {
 974     return false;
 975   }
 976 }
 977
 978
 979 /**
 980  * Return true if the NAV2 FROM flag should be active.
 981  */
 982 bool
 983 FGRadioStack::get_nav2_from_flag () const
 984 {
 985   if (nav2_inrange) {
 986     double offset = fabs(nav2_heading - nav2_radial);
 987     if (nav2_loc)
 988       return false;
 989     else
 990       return (offset > 90.0 && offset < 270.0);
 991   } else {
 992     return false;
 993   }
 994 }
 995