src/Cockpit/radiostack.cxx

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