]> git.mxchange.org Git - flightgear.git/blob - src/Cockpit/navcom.cxx
f4c47dbd634d1ecd3e22e1a624c031d16c2ca141
[flightgear.git] / src / Cockpit / navcom.cxx
1 // navcom.cxx -- class to manage a navcom instance
2 //
3 // Written by Curtis Olson, started April 2000.
4 //
5 // Copyright (C) 2000 - 2002  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 <stdio.h>      // snprintf
29
30 #include <simgear/compiler.h>
31 #include <simgear/math/sg_random.h>
32
33 #include <Aircraft/aircraft.hxx>
34 #include <Navaids/ilslist.hxx>
35 #include <Navaids/navlist.hxx>
36 #include <Time/FGEventMgr.hxx>
37
38 #include "navcom.hxx"
39
40 #include <string>
41 SG_USING_STD(string);
42
43
44 // Constructor
45 FGNavCom::FGNavCom() :
46     lon_node(fgGetNode("/position/longitude-deg", true)),
47     lat_node(fgGetNode("/position/latitude-deg", true)),
48     alt_node(fgGetNode("/position/altitude-ft", true)),
49     last_nav_id(""),
50     last_nav_vor(false),
51     nav_play_count(0),
52     nav_last_time(0),
53     need_update(true),
54     power_btn(true),
55     comm_freq(0.0),
56     comm_alt_freq(0.0),
57     comm_vol_btn(0.0),
58     nav_freq(0.0),
59     nav_alt_freq(0.0),
60     nav_radial(0.0),
61     nav_vol_btn(0.0),
62     nav_ident_btn(true)
63 {
64     SGPath path( globals->get_fg_root() );
65     SGPath term = path;
66     term.append( "Navaids/range.term" );
67     SGPath low = path;
68     low.append( "Navaids/range.low" );
69     SGPath high = path;
70     high.append( "Navaids/range.high" );
71
72     term_tbl = new SGInterpTable( term.str() );
73     low_tbl = new SGInterpTable( low.str() );
74     high_tbl = new SGInterpTable( high.str() );
75
76 }
77
78
79 // Destructor
80 FGNavCom::~FGNavCom() 
81 {
82     delete term_tbl;
83     delete low_tbl;
84     delete high_tbl;
85 }
86
87
88 void
89 FGNavCom::init ()
90 {
91     morse.init();
92
93     // We assume that index is valid now (it must be set before init()
94     // is called.)
95     char propname[256];
96
97     sprintf( propname, "/systems/electrical/outputs/navcom[%d]", index );
98     // default to true in case no electrical system defined.
99     fgSetDouble( propname, 60.0 );
100     bus_power = fgGetNode( propname, true );
101
102     sprintf( propname, "/instrumentation/comm[%d]/servicable", index );
103     com_servicable = fgGetNode( propname, true );
104     com_servicable->setBoolValue( true );
105
106     sprintf( propname, "/instrumentation/nav[%d]/servicable", index );
107     nav_servicable = fgGetNode( propname, true );
108     nav_servicable->setBoolValue( true );
109
110     sprintf( propname, "/instrumentation/vor[%d]/cdi/servicable", index );
111     cdi_servicable = fgGetNode( propname, true );
112     cdi_servicable->setBoolValue( true );
113
114     sprintf( propname, "/instrumentation/vor[%d]/gs/servicable", index );
115     gs_servicable = fgGetNode( propname, true );
116     gs_servicable->setBoolValue( true );
117
118     sprintf( propname, "/instrumentation/vor[%d]/to-from/servicable", index );
119     tofrom_servicable = fgGetNode( propname, true );
120     tofrom_servicable->setBoolValue( true );
121 }
122
123 void
124 FGNavCom::bind ()
125 {
126     char propname[256];
127
128                                 // User inputs
129     sprintf( propname, "/radios/comm[%d]/inputs/power-btn", index );
130     fgTie( propname, this,
131            &FGNavCom::get_power_btn, &FGNavCom::set_power_btn );
132     fgSetArchivable( propname );
133
134     sprintf( propname, "/radios/comm[%d]/frequencies/selected-mhz", index );
135     fgTie( propname, this, &FGNavCom::get_comm_freq, &FGNavCom::set_comm_freq );
136     fgSetArchivable( propname );
137
138     sprintf( propname, "/radios/comm[%d]/frequencies/standby-mhz", index );
139     fgTie( propname, this,
140            &FGNavCom::get_comm_alt_freq, &FGNavCom::set_comm_alt_freq );
141     fgSetArchivable( propname );
142
143     sprintf( propname, "/radios/comm[%d]/volume", index );
144     fgTie( propname, this,
145            &FGNavCom::get_comm_vol_btn, &FGNavCom::set_comm_vol_btn );
146     fgSetArchivable( propname );
147
148     sprintf( propname, "/radios/nav[%d]/frequencies/selected-mhz", index );
149     fgTie( propname, this,
150           &FGNavCom::get_nav_freq, &FGNavCom::set_nav_freq );
151     fgSetArchivable( propname );
152
153     sprintf( propname, "/radios/nav[%d]/frequencies/standby-mhz", index );
154     fgTie( propname , this,
155            &FGNavCom::get_nav_alt_freq, &FGNavCom::set_nav_alt_freq);
156     fgSetArchivable( propname );
157
158     sprintf( propname, "/radios/nav[%d]/radials/selected-deg", index );
159     fgTie( propname, this,
160            &FGNavCom::get_nav_sel_radial, &FGNavCom::set_nav_sel_radial );
161     fgSetArchivable( propname );
162
163     sprintf( propname, "/radios/nav[%d]/volume", index );
164     fgTie( propname, this,
165            &FGNavCom::get_nav_vol_btn, &FGNavCom::set_nav_vol_btn );
166     fgSetArchivable( propname );
167
168     sprintf( propname, "/radios/nav[%d]/ident", index );
169     fgTie( propname, this,
170            &FGNavCom::get_nav_ident_btn, &FGNavCom::set_nav_ident_btn );
171     fgSetArchivable( propname );
172
173                                 // Radio outputs
174     sprintf( propname, "/radios/nav[%d]/radials/actual-deg", index );
175     fgTie( propname,  this, &FGNavCom::get_nav_radial );
176
177     sprintf( propname, "/radios/nav[%d]/to-flag", index );
178     fgTie( propname, this, &FGNavCom::get_nav_to_flag );
179
180     sprintf( propname, "/radios/nav[%d]/from-flag", index );
181     fgTie( propname, this, &FGNavCom::get_nav_from_flag );
182
183     sprintf( propname, "/radios/nav[%d]/in-range", index );
184     fgTie( propname, this, &FGNavCom::get_nav_inrange );
185
186     sprintf( propname, "/radios/nav[%d]/heading-needle-deflection", index );
187     fgTie( propname, this, &FGNavCom::get_nav_heading_needle_deflection );
188
189     sprintf( propname, "/radios/nav[%d]/gs-needle-deflection", index );
190     fgTie( propname, this, &FGNavCom::get_nav_gs_needle_deflection );
191
192     // end of binding
193 }
194
195
196 void
197 FGNavCom::unbind ()
198 {
199     char propname[256];
200
201     sprintf( propname, "/radios/comm[%d]/inputs/power-btn", index );
202     fgUntie( propname );
203     sprintf( propname, "/radios/comm[%d]/frequencies/selected-mhz", index );
204     fgUntie( propname );
205     sprintf( propname, "/radios/comm[%d]/frequencies/standby-mhz", index );
206     fgUntie( propname );
207
208     sprintf( propname, "/radios/nav[%d]/frequencies/selected-mhz", index );
209     fgUntie( propname );
210     sprintf( propname, "/radios/nav[%d]/frequencies/standby-mhz", index );
211     fgUntie( propname );
212     sprintf( propname, "/radios/nav[%d]/radials/actual-deg", index );
213     fgUntie( propname );
214     sprintf( propname, "/radios/nav[%d]/radials/selected-deg", index );
215     fgUntie( propname );
216     sprintf( propname, "/radios/nav[%d]/ident", index );
217     fgUntie( propname );
218     sprintf( propname, "/radios/nav[%d]/to-flag", index );
219     fgUntie( propname );
220     sprintf( propname, "/radios/nav[%d]/from-flag", index );
221     fgUntie( propname );
222     sprintf( propname, "/radios/nav[%d]/in-range", index );
223     fgUntie( propname );
224     sprintf( propname, "/radios/nav[%d]/heading-needle-deflection", index );
225     fgUntie( propname );
226     sprintf( propname, "/radios/nav[%d]/gs-needle-deflection", index );
227     fgUntie( propname );
228 }
229
230
231 // model standard VOR/DME/TACAN service volumes as per AIM 1-1-8
232 double FGNavCom::adjustNavRange( double stationElev, double aircraftElev,
233                                  double nominalRange )
234 {
235     // extend out actual usable range to be 1.3x the published safe range
236     const double usability_factor = 1.3;
237
238     // assumptions we model the standard service volume, plus
239     // ... rather than specifying a cylinder, we model a cone that
240     // contains the cylinder.  Then we put an upside down cone on top
241     // to model diminishing returns at too-high altitudes.
242
243     // altitude difference
244     double alt = ( aircraftElev * SG_METER_TO_FEET - stationElev );
245     // cout << "aircraft elev = " << aircraftElev * SG_METER_TO_FEET
246     //      << " station elev = " << stationElev << endl;
247
248     if ( nominalRange < 25.0 + SG_EPSILON ) {
249         // Standard Terminal Service Volume
250         return term_tbl->interpolate( alt ) * usability_factor;
251     } else if ( nominalRange < 50.0 + SG_EPSILON ) {
252         // Standard Low Altitude Service Volume
253         // table is based on range of 40, scale to actual range
254         return low_tbl->interpolate( alt ) * nominalRange / 40.0
255             * usability_factor;
256     } else {
257         // Standard High Altitude Service Volume
258         // table is based on range of 130, scale to actual range
259         return high_tbl->interpolate( alt ) * nominalRange / 130.0
260             * usability_factor;
261     }
262 }
263
264
265 // model standard ILS service volumes as per AIM 1-1-9
266 double FGNavCom::adjustILSRange( double stationElev, double aircraftElev,
267                                      double offsetDegrees, double distance )
268 {
269     // assumptions we model the standard service volume, plus
270
271     // altitude difference
272     // double alt = ( aircraftElev * SG_METER_TO_FEET - stationElev );
273     double offset = fabs( offsetDegrees );
274
275     if ( offset < 10 ) {
276         return FG_ILS_DEFAULT_RANGE;
277     } else if ( offset < 35 ) {
278         return 10 + (35 - offset) * (FG_ILS_DEFAULT_RANGE - 10) / 25;
279     } else if ( offset < 45 ) {
280         return (45 - offset);
281     } else if ( offset > 170 ) {
282         return FG_ILS_DEFAULT_RANGE;
283     } else if ( offset > 145 ) {
284         return 10 + (offset - 145) * (FG_ILS_DEFAULT_RANGE - 10) / 25;
285     } else if ( offset > 135 ) {
286         return (offset - 135);
287     } else {
288         return 0;
289     }
290 }
291
292
293 // Update the various nav values based on position and valid tuned in navs
294 void 
295 FGNavCom::update(double dt) 
296 {
297     double lon = lon_node->getDoubleValue() * SGD_DEGREES_TO_RADIANS;
298     double lat = lat_node->getDoubleValue() * SGD_DEGREES_TO_RADIANS;
299     double elev = alt_node->getDoubleValue() * SG_FEET_TO_METER;
300
301     need_update = false;
302
303     Point3D aircraft = sgGeodToCart( Point3D( lon, lat, elev ) );
304     Point3D station;
305     double az1, az2, s;
306
307     ////////////////////////////////////////////////////////////////////////
308     // Nav.
309     ////////////////////////////////////////////////////////////////////////
310
311     if ( nav_valid && power_btn && (bus_power->getDoubleValue() > 1.0)
312          && nav_servicable->getBoolValue() )
313     {
314         station = Point3D( nav_x, nav_y, nav_z );
315         nav_loc_dist = aircraft.distance3D( station );
316
317         if ( nav_has_gs ) {
318             station = Point3D( nav_gs_x, nav_gs_y, nav_gs_z );
319             nav_gs_dist = aircraft.distance3D( station );
320         } else {
321             nav_gs_dist = 0.0;
322         }
323         
324         // wgs84 heading
325         geo_inverse_wgs_84( elev, lat * SGD_RADIANS_TO_DEGREES, lon * SGD_RADIANS_TO_DEGREES, 
326                             nav_loclat, nav_loclon,
327                             &az1, &az2, &s );
328         // cout << "az1 = " << az1 << " magvar = " << nav_magvar << endl;
329         nav_heading = az1 - nav_magvar;
330         // cout << " heading = " << nav_heading
331         //      << " dist = " << nav_dist << endl;
332
333         if ( nav_loc ) {
334             double offset = nav_heading - nav_radial;
335             while ( offset < -180.0 ) { offset += 360.0; }
336             while ( offset > 180.0 ) { offset -= 360.0; }
337             // cout << "ils offset = " << offset << endl;
338             nav_effective_range = adjustILSRange(nav_elev, elev, offset,
339                                                   nav_loc_dist * SG_METER_TO_NM );
340         } else {
341             nav_effective_range = adjustNavRange(nav_elev, elev, nav_range);
342         }
343         // cout << "nav range = " << nav_effective_range
344         //      << " (" << nav_range << ")" << endl;
345
346         if ( nav_loc_dist < nav_effective_range * SG_NM_TO_METER ) {
347             nav_inrange = true;
348         } else if ( nav_loc_dist < 2 * nav_effective_range * SG_NM_TO_METER ) {
349             nav_inrange = sg_random() < 
350                 ( 2 * nav_effective_range * SG_NM_TO_METER - nav_loc_dist ) /
351                 (nav_effective_range * SG_NM_TO_METER);
352         } else {
353             nav_inrange = false;
354         }
355
356         if ( !nav_loc ) {
357             nav_radial = nav_sel_radial;
358         }
359     } else {
360         nav_inrange = false;
361         // cout << "not picking up vor. :-(" << endl;
362     }
363
364 #ifdef ENABLE_AUDIO_SUPPORT
365     if ( nav_valid && nav_inrange && nav_servicable->getBoolValue() ) {
366         // play station ident via audio system if on + ident,
367         // otherwise turn it off
368         if ( power_btn && (bus_power->getDoubleValue() > 1.0)
369              && nav_ident_btn )
370         {
371             FGSimpleSound *sound;
372             sound = globals->get_soundmgr()->find( nav_fx_name );
373             if ( sound != NULL ) {
374                 sound->set_volume( nav_vol_btn );
375             } else {
376                 SG_LOG( SG_COCKPIT, SG_ALERT,
377                         "Can't find nav-vor-ident sound" );
378             }
379             sound = globals->get_soundmgr()->find( dme_fx_name );
380             if ( sound != NULL ) {
381                 sound->set_volume( nav_vol_btn );
382             } else {
383                 SG_LOG( SG_COCKPIT, SG_ALERT,
384                         "Can't find nav-dme-ident sound" );
385             }
386             // cout << "nav_last_time = " << nav_last_time << " ";
387             // cout << "cur_time = "
388             //      << globals->get_time_params()->get_cur_time();
389             if ( nav_last_time <
390                  globals->get_time_params()->get_cur_time() - 30 ) {
391                 nav_last_time = globals->get_time_params()->get_cur_time();
392                 nav_play_count = 0;
393             }
394             // cout << " nav_play_count = " << nav_play_count << endl;
395             // cout << "playing = "
396             //      << globals->get_soundmgr()->is_playing(nav_fx_name)
397             //      << endl;
398             if ( nav_play_count < 4 ) {
399                 // play VOR ident
400                 if ( !globals->get_soundmgr()->is_playing(nav_fx_name) ) {
401                     globals->get_soundmgr()->play_once( nav_fx_name );
402                     ++nav_play_count;
403                 }
404             } else if ( nav_play_count < 5 && nav_has_dme ) {
405                 // play DME ident
406                 if ( !globals->get_soundmgr()->is_playing(nav_fx_name) &&
407                      !globals->get_soundmgr()->is_playing(dme_fx_name) ) {
408                     globals->get_soundmgr()->play_once( dme_fx_name );
409                     ++nav_play_count;
410                 }
411             }
412         } else {
413             globals->get_soundmgr()->stop( nav_fx_name );
414             globals->get_soundmgr()->stop( dme_fx_name );
415         }
416     }
417 #endif
418
419 }
420
421
422 // Update current nav/adf radio stations based on current postition
423 void FGNavCom::search() 
424 {
425     double lon = lon_node->getDoubleValue() * SGD_DEGREES_TO_RADIANS;
426     double lat = lat_node->getDoubleValue() * SGD_DEGREES_TO_RADIANS;
427     double elev = alt_node->getDoubleValue() * SG_FEET_TO_METER;
428
429     FGILS ils;
430     FGNav nav;
431
432     ////////////////////////////////////////////////////////////////////////
433     // Nav.
434     ////////////////////////////////////////////////////////////////////////
435
436     if ( current_ilslist->query( lon, lat, elev, nav_freq, &ils ) ) {
437         nav_id = ils.get_locident();
438         nav_valid = true;
439         if ( last_nav_id != nav_id || last_nav_vor ) {
440             nav_trans_ident = ils.get_trans_ident();
441             last_nav_id = nav_id;
442             last_nav_vor = false;
443             nav_loc = true;
444             nav_has_dme = ils.get_has_dme();
445             nav_has_gs = ils.get_has_gs();
446
447             nav_loclon = ils.get_loclon();
448             nav_loclat = ils.get_loclat();
449             nav_gslon = ils.get_gslon();
450             nav_gslat = ils.get_gslat();
451             nav_elev = ils.get_gselev();
452             nav_magvar = 0;
453             nav_range = FG_ILS_DEFAULT_RANGE;
454             nav_effective_range = nav_range;
455             nav_target_gs = ils.get_gsangle();
456             nav_radial = ils.get_locheading();
457             while ( nav_radial <   0.0 ) { nav_radial += 360.0; }
458             while ( nav_radial > 360.0 ) { nav_radial -= 360.0; }
459             nav_x = ils.get_x();
460             nav_y = ils.get_y();
461             nav_z = ils.get_z();
462             nav_gs_x = ils.get_gs_x();
463             nav_gs_y = ils.get_gs_y();
464             nav_gs_z = ils.get_gs_z();
465
466 #ifdef ENABLE_AUDIO_SUPPORT
467             if ( globals->get_soundmgr()->exists( nav_fx_name ) ) {
468                 globals->get_soundmgr()->remove( nav_fx_name );
469             }
470             FGSimpleSound *sound;
471             sound = morse.make_ident( nav_trans_ident, LO_FREQUENCY );
472             sound->set_volume( 0.3 );
473             globals->get_soundmgr()->add( sound, nav_fx_name );
474
475             if ( globals->get_soundmgr()->exists( dme_fx_name ) ) {
476                 globals->get_soundmgr()->remove( dme_fx_name );
477             }
478             sound = morse.make_ident( nav_trans_ident, HI_FREQUENCY );
479             sound->set_volume( 0.3 );
480             globals->get_soundmgr()->add( sound, dme_fx_name );
481
482             int offset = (int)(sg_random() * 30.0);
483             nav_play_count = offset / 4;
484             nav_last_time = globals->get_time_params()->get_cur_time() -
485                 offset;
486             // cout << "offset = " << offset << " play_count = "
487             //      << nav_play_count
488             //      << " nav_last_time = " << nav_last_time
489             //      << " current time = "
490             //      << globals->get_time_params()->get_cur_time() << endl;
491 #endif
492
493             // cout << "Found an ils station in range" << endl;
494             // cout << " id = " << ils.get_locident() << endl;
495         }
496     } else if ( current_navlist->query( lon, lat, elev, nav_freq, &nav ) ) {
497         nav_id = nav.get_ident();
498         nav_valid = true;
499         if ( last_nav_id != nav_id || !last_nav_vor ) {
500             last_nav_id = nav_id;
501             last_nav_vor = true;
502             nav_trans_ident = nav.get_trans_ident();
503             nav_loc = false;
504             nav_has_dme = nav.get_has_dme();
505             nav_has_gs = false;
506             nav_loclon = nav.get_lon();
507             nav_loclat = nav.get_lat();
508             nav_elev = nav.get_elev();
509             nav_magvar = nav.get_magvar();
510             nav_range = nav.get_range();
511             nav_effective_range = adjustNavRange(nav_elev, elev, nav_range);
512             nav_target_gs = 0.0;
513             nav_radial = nav_sel_radial;
514             nav_x = nav.get_x();
515             nav_y = nav.get_y();
516             nav_z = nav.get_z();
517
518 #ifdef ENABLE_AUDIO_SUPPORT
519             if ( globals->get_soundmgr()->exists( nav_fx_name ) ) {
520                 globals->get_soundmgr()->remove( nav_fx_name );
521             }
522             FGSimpleSound *sound;
523             sound = morse.make_ident( nav_trans_ident, LO_FREQUENCY );
524             sound->set_volume( 0.3 );
525             if ( globals->get_soundmgr()->add( sound, nav_fx_name ) ) {
526                 // cout << "Added nav-vor-ident sound" << endl;
527             } else {
528                 cout << "Failed to add v1-vor-ident sound" << endl;
529             }
530
531             if ( globals->get_soundmgr()->exists( dme_fx_name ) ) {
532                 globals->get_soundmgr()->remove( dme_fx_name );
533             }
534             sound = morse.make_ident( nav_trans_ident, HI_FREQUENCY );
535             sound->set_volume( 0.3 );
536             globals->get_soundmgr()->add( sound, dme_fx_name );
537
538             int offset = (int)(sg_random() * 30.0);
539             nav_play_count = offset / 4;
540             nav_last_time = globals->get_time_params()->get_cur_time() -
541                 offset;
542             // cout << "offset = " << offset << " play_count = "
543             //      << nav_play_count << " nav_last_time = "
544             //      << nav_last_time << " current time = "
545             //      << globals->get_time_params()->get_cur_time() << endl;
546 #endif
547
548             // cout << "Found a vor station in range" << endl;
549             // cout << " id = " << nav.get_ident() << endl;
550         }
551     } else {
552         nav_valid = false;
553         nav_id = "";
554         nav_radial = 0;
555         nav_trans_ident = "";
556         last_nav_id = "";
557 #ifdef ENABLE_AUDIO_SUPPORT
558         if ( ! globals->get_soundmgr()->remove( nav_fx_name ) ) {
559             cout << "Failed to remove nav-vor-ident sound" << endl;
560         }
561         globals->get_soundmgr()->remove( dme_fx_name );
562 #endif
563         // cout << "not picking up vor1. :-(" << endl;
564     }
565 }
566
567
568 // return the amount of heading needle deflection, returns a value
569 // clamped to the range of ( -10 , 10 )
570 double FGNavCom::get_nav_heading_needle_deflection() const {
571     double r;
572
573     if ( nav_inrange
574          && nav_servicable->getBoolValue() && cdi_servicable->getBoolValue() )
575     {
576         r = nav_heading - nav_radial;
577         // cout << "Radial = " << nav_radial 
578         //      << "  Bearing = " << nav_heading << endl;
579     
580         while ( r >  180.0 ) { r -= 360.0;}
581         while ( r < -180.0 ) { r += 360.0;}
582         if ( fabs(r) > 90.0 )
583             r = ( r<0.0 ? -r-180.0 : -r+180.0 );
584
585         // According to Robin Peel, the ILS is 4x more sensitive than a vor
586         if ( nav_loc ) { r *= 4.0; }
587         if ( r < -10.0 ) { r = -10.0; }
588         if ( r >  10.0 ) { r = 10.0; }
589     } else {
590         r = 0.0;
591     }
592
593     return r;
594 }
595
596
597 // return the amount of glide slope needle deflection (.i.e. the
598 // number of degrees we are off the glide slope * 5.0
599 double FGNavCom::get_nav_gs_needle_deflection() const {
600     if ( nav_inrange && nav_has_gs
601          && nav_servicable->getBoolValue() && gs_servicable->getBoolValue() )
602     {
603         double x = nav_gs_dist;
604         double y = (fgGetDouble("/position/altitude-ft") - nav_elev)
605             * SG_FEET_TO_METER;
606         double angle = atan2( y, x ) * SGD_RADIANS_TO_DEGREES;
607         return (nav_target_gs - angle) * 5.0;
608     } else {
609         return 0.0;
610     }
611 }
612
613
614 /**
615  * Return true if the NAV TO flag should be active.
616  */
617 bool 
618 FGNavCom::get_nav_to_flag () const
619 {
620     if ( nav_inrange
621          && nav_servicable->getBoolValue()
622          && tofrom_servicable->getBoolValue() )
623     {
624         double offset = fabs(nav_heading - nav_radial);
625         if (nav_loc) {
626             return true;
627         } else {
628             return (offset <= 90.0 || offset >= 270.0);
629         }
630     } else {
631         return false;
632     }
633 }
634
635
636 /**
637  * Return true if the NAV FROM flag should be active.
638  */
639 bool
640 FGNavCom::get_nav_from_flag () const
641 {
642     if ( nav_inrange
643          && nav_servicable->getBoolValue()
644          && tofrom_servicable->getBoolValue() ) {
645         double offset = fabs(nav_heading - nav_radial);
646         if (nav_loc) {
647             return false;
648         } else {
649           return (offset > 90.0 && offset < 270.0);
650         }
651     } else {
652         return false;
653     }
654 }