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