lon_node(fgGetNode("/position/longitude-deg", true)),
lat_node(fgGetNode("/position/latitude-deg", true)),
alt_node(fgGetNode("/position/altitude-ft", true)),
- power_btn(NULL),
- nav_freq(NULL),
- nav_alt_freq(NULL),
- fmt_freq(NULL),
- fmt_alt_freq(NULL),
- nav_sel_radial(NULL),
- nav_vol_btn(NULL),
- nav_ident_btn(NULL),
- audio_btn(NULL),
- nav_heading(NULL),
- nav_radial(NULL),
- reciprocal_radial(NULL),
- nav_target_radial_true(NULL),
- nav_target_auto_hdg(NULL),
- nav_to_flag(NULL),
- nav_from_flag(NULL),
- nav_inrange(NULL),
- nav_cdi_deflection(NULL),
- nav_cdi_xtrack_error(NULL),
- nav_has_gs(NULL),
- nav_loc(NULL),
- nav_loc_dist(NULL),
- nav_gs_deflection(NULL),
- nav_gs_rate_of_climb(NULL),
- nav_gs_dist(NULL),
- nav_id(NULL),
- nav_id_c1(NULL),
- nav_id_c2(NULL),
- nav_id_c3(NULL),
- nav_id_c4(NULL),
- last_nav_id(""),
+ power_btn_node(NULL),
+ freq_node(NULL),
+ alt_freq_node(NULL),
+ fmt_freq_node(NULL),
+ fmt_alt_freq_node(NULL),
+ sel_radial_node(NULL),
+ vol_btn_node(NULL),
+ ident_btn_node(NULL),
+ audio_btn_node(NULL),
+ heading_node(NULL),
+ radial_node(NULL),
+ recip_radial_node(NULL),
+ target_radial_true_node(NULL),
+ target_auto_hdg_node(NULL),
+ to_flag_node(NULL),
+ from_flag_node(NULL),
+ inrange_node(NULL),
+ cdi_deflection_node(NULL),
+ cdi_xtrack_error_node(NULL),
+ has_gs_node(NULL),
+ loc_node(NULL),
+ loc_dist_node(NULL),
+ gs_deflection_node(NULL),
+ gs_rate_of_climb_node(NULL),
+ gs_dist_node(NULL),
+ id_node(NULL),
+ id_c1_node(NULL),
+ id_c2_node(NULL),
+ id_c3_node(NULL),
+ id_c4_node(NULL),
+ last_id(""),
last_nav_vor(false),
nav_play_count(0),
nav_last_time(0),
SGPropertyNode *node = fgGetNode(branch.c_str(), num, true );
- bus_power =
+ bus_power_node =
fgGetNode(("/systems/electrical/outputs/" + name).c_str(), true);
// inputs
- power_btn = node->getChild("power-btn", 0, true);
- power_btn->setBoolValue( true );
- nav_vol_btn = node->getChild("volume", 0, true);
- nav_ident_btn = node->getChild("ident", 0, true);
- nav_ident_btn->setBoolValue( true );
- audio_btn = node->getChild("audio-btn", 0, true);
- audio_btn->setBoolValue( true );
+ power_btn_node = node->getChild("power-btn", 0, true);
+ power_btn_node->setBoolValue( true );
+ vol_btn_node = node->getChild("volume", 0, true);
+ ident_btn_node = node->getChild("ident", 0, true);
+ ident_btn_node->setBoolValue( true );
+ audio_btn_node = node->getChild("audio-btn", 0, true);
+ audio_btn_node->setBoolValue( true );
// frequencies
SGPropertyNode *subnode = node->getChild("frequencies", 0, true);
- nav_freq = subnode->getChild("selected-mhz", 0, true);
- nav_alt_freq = subnode->getChild("standby-mhz", 0, true);
- fmt_freq = subnode->getChild("selected-mhz-fmt", 0, true);
- fmt_alt_freq = subnode->getChild("standby-mhz-fmt", 0, true);
+ freq_node = subnode->getChild("selected-mhz", 0, true);
+ alt_freq_node = subnode->getChild("standby-mhz", 0, true);
+ fmt_freq_node = subnode->getChild("selected-mhz-fmt", 0, true);
+ fmt_alt_freq_node = subnode->getChild("standby-mhz-fmt", 0, true);
// radials
subnode = node->getChild("radials", 0, true);
- nav_sel_radial = subnode->getChild("selected-deg", 0, true);
- nav_radial = subnode->getChild("actual-deg", 0, true);
- reciprocal_radial = subnode->getChild("reciprocal-radial-deg", 0, true);
- nav_target_radial_true = subnode->getChild("target-radial-deg", 0, true);
- nav_target_auto_hdg = subnode->getChild("target-auto-hdg-deg", 0, true);
+ sel_radial_node = subnode->getChild("selected-deg", 0, true);
+ radial_node = subnode->getChild("actual-deg", 0, true);
+ recip_radial_node = subnode->getChild("reciprocal-radial-deg", 0, true);
+ target_radial_true_node = subnode->getChild("target-radial-deg", 0, true);
+ target_auto_hdg_node = subnode->getChild("target-auto-hdg-deg", 0, true);
// outputs
- nav_heading = node->getChild("heading-deg", 0, true);
- nav_to_flag = node->getChild("to-flag", 0, true);
- nav_from_flag = node->getChild("from-flag", 0, true);
- nav_inrange = node->getChild("in-range", 0, true);
- nav_cdi_deflection = node->getChild("heading-needle-deflection", 0, true);
- nav_cdi_xtrack_error = node->getChild("crosstrack-error-m", 0, true);
- nav_has_gs = node->getChild("has-gs", 0, true);
- nav_loc = node->getChild("nav-loc", 0, true);
- nav_loc_dist = node->getChild("nav-distance", 0, true);
- nav_gs_deflection = node->getChild("gs-needle-deflection", 0, true);
- nav_gs_rate_of_climb = node->getChild("gs-rate-of-climb", 0, true);
- nav_gs_dist = node->getChild("gs-distance", 0, true);
- nav_id = node->getChild("nav-id", 0, true);
- nav_id_c1 = node->getChild("nav-id_asc1", 0, true);
- nav_id_c2 = node->getChild("nav-id_asc2", 0, true);
- nav_id_c3 = node->getChild("nav-id_asc3", 0, true);
- nav_id_c4 = node->getChild("nav-id_asc4", 0, true);
-
- nav_serviceable = node->getChild("serviceable", 0, true);
- cdi_serviceable = (node->getChild("cdi", 0, true))
+ heading_node = node->getChild("heading-deg", 0, true);
+ to_flag_node = node->getChild("to-flag", 0, true);
+ from_flag_node = node->getChild("from-flag", 0, true);
+ inrange_node = node->getChild("in-range", 0, true);
+ cdi_deflection_node = node->getChild("heading-needle-deflection", 0, true);
+ cdi_xtrack_error_node = node->getChild("crosstrack-error-m", 0, true);
+ has_gs_node = node->getChild("has-gs", 0, true);
+ loc_node = node->getChild("nav-loc", 0, true);
+ loc_dist_node = node->getChild("nav-distance", 0, true);
+ gs_deflection_node = node->getChild("gs-needle-deflection", 0, true);
+ gs_rate_of_climb_node = node->getChild("gs-rate-of-climb", 0, true);
+ gs_dist_node = node->getChild("gs-distance", 0, true);
+ id_node = node->getChild("nav-id", 0, true);
+ id_c1_node = node->getChild("nav-id_asc1", 0, true);
+ id_c2_node = node->getChild("nav-id_asc2", 0, true);
+ id_c3_node = node->getChild("nav-id_asc3", 0, true);
+ id_c4_node = node->getChild("nav-id_asc4", 0, true);
+
+ nav_serviceable_node = node->getChild("serviceable", 0, true);
+ cdi_serviceable_node = (node->getChild("cdi", 0, true))
->getChild("serviceable", 0, true);
- gs_serviceable = (node->getChild("gs", 0, true))
+ gs_serviceable_node = (node->getChild("gs", 0, true))
->getChild("serviceable");
- tofrom_serviceable = (node->getChild("to-from", 0, true))
+ tofrom_serviceable_node = (node->getChild("to-from", 0, true))
->getChild("serviceable", 0, true);
- nav_slaved_to_gps = node->getChild("slaved-to-gps", 0, true);
+ nav_slaved_to_gps_node = node->getChild("slaved-to-gps", 0, true);
- gps_cdi_deflection = fgGetNode("/instrumentation/gps/cdi-deflection", true);
- gps_to_flag = fgGetNode("/instrumentation/gps/to-flag", true);
- gps_from_flag = fgGetNode("/instrumentation/gps/from-flag", true);
+ gps_cdi_deflection_node = fgGetNode("/instrumentation/gps/cdi-deflection", true);
+ gps_to_flag_node = fgGetNode("/instrumentation/gps/to-flag", true);
+ gps_from_flag_node = fgGetNode("/instrumentation/gps/from-flag", true);
std::ostringstream temp;
temp << name << "nav-ident" << num;
// Create "formatted" versions of the nav frequencies for
// consistant display output.
char tmp[16];
- sprintf( tmp, "%.2f", nav_freq->getDoubleValue() );
- fmt_freq->setStringValue(tmp);
- sprintf( tmp, "%.2f", nav_alt_freq->getDoubleValue() );
- fmt_alt_freq->setStringValue(tmp);
+ sprintf( tmp, "%.2f", freq_node->getDoubleValue() );
+ fmt_freq_node->setStringValue(tmp);
+ sprintf( tmp, "%.2f", alt_freq_node->getDoubleValue() );
+ fmt_alt_freq_node->setStringValue(tmp);
// On timeout, scan again
_time_before_search_sec -= dt;
////////////////////////////////////////////////////////////////////////
// cout << "nav_valid = " << nav_valid
- // << " power_btn = " << power_btn->getBoolValue()
- // << " bus_power = " << bus_power->getDoubleValue()
+ // << " power_btn = " << power_btn_node->getBoolValue()
+ // << " bus_power = " << bus_power_node->getDoubleValue()
// << " nav_serviceable = " << nav_serviceable->getBoolValue()
// << endl;
- if ( nav_valid && power_btn->getBoolValue()
- && (bus_power->getDoubleValue() > 1.0)
- && nav_serviceable->getBoolValue() )
+ if ( nav_valid && power_btn_node->getBoolValue()
+ && (bus_power_node->getDoubleValue() > 1.0)
+ && nav_serviceable_node->getBoolValue() )
{
station = Point3D( nav_x, nav_y, nav_z );
- nav_loc_dist->setDoubleValue( aircraft.distance3D( station ) );
+ loc_dist_node->setDoubleValue( aircraft.distance3D( station ) );
// cout << "station = " << station << " dist = "
- // << nav_loc_dist->getDoubleValue() << endl;
+ // << loc_dist_node->getDoubleValue() << endl;
- if ( nav_has_gs->getBoolValue() ) {
+ if ( has_gs_node->getBoolValue() ) {
// find closest distance to the gs base line
sgdVec3 p;
sgdSetVec3( p, aircraft.x(), aircraft.y(), aircraft.z() );
sgdSetVec3( p0, nav_gs_x, nav_gs_y, nav_gs_z );
double dist = sgdClosestPointToLineDistSquared( p, p0,
gs_base_vec );
- nav_gs_dist->setDoubleValue( sqrt( dist ) );
- // cout << "nav_gs_dist = " << nav_gs_dist->getDoubleValue()
+ gs_dist_node->setDoubleValue( sqrt( dist ) );
+ // cout << "nav_gs_dist = " << gs_dist_node->getDoubleValue()
// << endl;
Point3D tmp( nav_gs_x, nav_gs_y, nav_gs_z );
while ( r > 180.0 ) { r -= 360.0;}
while ( r < -180.0 ) { r += 360.0;}
if ( r >= -90.0 && r <= 90.0 ) {
- nav_gs_dist_signed = nav_gs_dist->getDoubleValue();
+ nav_gs_dist_signed = gs_dist_node->getDoubleValue();
} else {
- nav_gs_dist_signed = -nav_gs_dist->getDoubleValue();
+ nav_gs_dist_signed = -gs_dist_node->getDoubleValue();
}
/* cout << "Target Radial = " << nav_target_radial
<< " Bearing = " << az1
<< endl; */
} else {
- nav_gs_dist->setDoubleValue( 0.0 );
+ gs_dist_node->setDoubleValue( 0.0 );
}
// wgs84 heading to localizer
nav_loclat, nav_loclon,
&hdg, &az2, &s );
// cout << "az1 = " << az1 << " magvar = " << nav_magvar << endl;
- nav_heading->setDoubleValue( hdg );
+ heading_node->setDoubleValue( hdg );
double radial = az2 - nav_twist;
double recip = radial + 180.0;
if ( recip >= 360.0 ) { recip -= 360.0; }
- nav_radial->setDoubleValue( radial );
- reciprocal_radial->setDoubleValue( recip );
- // cout << " heading = " << nav_heading
+ radial_node->setDoubleValue( radial );
+ recip_radial_node->setDoubleValue( recip );
+ // cout << " heading = " << heading_node->getDoubleValue()
// << " dist = " << nav_dist << endl;
- if ( nav_loc->getBoolValue() ) {
+ if ( loc_node->getBoolValue() ) {
double offset = radial - nav_target_radial;
while ( offset < -180.0 ) { offset += 360.0; }
while ( offset > 180.0 ) { offset -= 360.0; }
// cout << "ils offset = " << offset << endl;
nav_effective_range
= adjustILSRange( nav_elev, elev, offset,
- nav_loc_dist->getDoubleValue()
+ loc_dist_node->getDoubleValue()
* SG_METER_TO_NM );
} else {
nav_effective_range = adjustNavRange( nav_elev, elev, nav_range );
// cout << "nav range = " << nav_effective_range
// << " (" << nav_range << ")" << endl;
- if ( nav_loc_dist->getDoubleValue()
+ if ( loc_dist_node->getDoubleValue()
< nav_effective_range * SG_NM_TO_METER )
{
- nav_inrange->setBoolValue( true );
- } else if ( nav_loc_dist->getDoubleValue()
+ inrange_node->setBoolValue( true );
+ } else if ( loc_dist_node->getDoubleValue()
< 2 * nav_effective_range * SG_NM_TO_METER )
{
- nav_inrange->setBoolValue( sg_random() <
+ inrange_node->setBoolValue( sg_random() <
( 2 * nav_effective_range * SG_NM_TO_METER
- - nav_loc_dist->getDoubleValue() ) /
+ - loc_dist_node->getDoubleValue() ) /
(nav_effective_range * SG_NM_TO_METER) );
} else {
- nav_inrange->setBoolValue( false );
+ inrange_node->setBoolValue( false );
}
- if ( !nav_loc->getBoolValue() ) {
- nav_target_radial = nav_sel_radial->getDoubleValue();
+ if ( !loc_node->getBoolValue() ) {
+ nav_target_radial = sel_radial_node->getDoubleValue();
}
// Calculate some values for the nav/ils hold autopilot
double cur_radial = recip;
- if ( nav_loc->getBoolValue() ) {
+ if ( loc_node->getBoolValue() ) {
// ILS localizers radials are already "true" in our
// database
} else {
cur_radial += nav_twist;
}
- if ( nav_from_flag->getBoolValue() ) {
+ if ( from_flag_node->getBoolValue() ) {
cur_radial += 180.0;
while ( cur_radial >= 360.0 ) { cur_radial -= 360.0; }
}
// determine the target radial in "true" heading
double trtrue = 0.0;
- if ( nav_loc->getBoolValue() ) {
+ if ( loc_node->getBoolValue() ) {
// ILS localizers radials are already "true" in our
// database
trtrue = nav_target_radial;
while ( trtrue < 0.0 ) { trtrue += 360.0; }
while ( trtrue > 360.0 ) { trtrue -= 360.0; }
- nav_target_radial_true->setDoubleValue( trtrue );
+ target_radial_true_node->setDoubleValue( trtrue );
// determine the heading adjustment needed.
// over 8km scale by 3.0
// because the overstated error helps drive it to the radial in a
// moderate cross wind.
double adjustment = 0.0;
- if (nav_loc_dist->getDoubleValue() > 8000) {
- adjustment = nav_cdi_deflection->getDoubleValue() * 3.0;
+ if (loc_dist_node->getDoubleValue() > 8000) {
+ adjustment = cdi_deflection_node->getDoubleValue() * 3.0;
} else {
- adjustment = nav_cdi_deflection->getDoubleValue() * 10.0;
+ adjustment = cdi_deflection_node->getDoubleValue() * 10.0;
}
SG_CLAMP_RANGE( adjustment, -30.0, 30.0 );
double nta_hdg = trtrue + adjustment;
while ( nta_hdg < 0.0 ) { nta_hdg += 360.0; }
while ( nta_hdg > 360.0 ) { nta_hdg -= 360.0; }
- nav_target_auto_hdg->setDoubleValue( nta_hdg );
+ target_auto_hdg_node->setDoubleValue( nta_hdg );
// cross track error
// ????
// Calculate desired rate of climb for intercepting the GS
- double x = nav_gs_dist->getDoubleValue();
+ double x = gs_dist_node->getDoubleValue();
double y = (alt_node->getDoubleValue() - nav_elev)
* SG_FEET_TO_METER;
double current_angle = atan2( y, x ) * SGD_RADIANS_TO_DEGREES;
// double horiz_vel = airspeed_node->getFloatValue()
// * SG_FEET_TO_METER * 60.0;
- nav_gs_rate_of_climb
+ gs_rate_of_climb_node
->setDoubleValue( -sin( des_angle * SGD_DEGREES_TO_RADIANS )
* horiz_vel * SG_METER_TO_FEET );
}
} else {
- nav_inrange->setBoolValue( false );
+ inrange_node->setBoolValue( false );
// cout << "not picking up vor. :-(" << endl;
}
// compute to/from flag status
double value = false;
- double offset = fabs(nav_radial->getDoubleValue() - nav_target_radial);
- if ( nav_slaved_to_gps->getBoolValue() ) {
- value = gps_to_flag->getBoolValue();
- } else if ( nav_inrange->getBoolValue()
- && nav_serviceable->getBoolValue()
- && tofrom_serviceable->getBoolValue() )
+ double offset = fabs(radial_node->getDoubleValue() - nav_target_radial);
+ if ( nav_slaved_to_gps_node->getBoolValue() ) {
+ value = gps_to_flag_node->getBoolValue();
+ } else if ( inrange_node->getBoolValue()
+ && nav_serviceable_node->getBoolValue()
+ && tofrom_serviceable_node->getBoolValue() )
{
- if ( nav_loc->getBoolValue() ) {
+ if ( loc_node->getBoolValue() ) {
value = true;
} else {
value = !(offset <= 90.0 || offset >= 270.0);
}
}
- nav_to_flag->setBoolValue( value );
+ to_flag_node->setBoolValue( value );
value = false;
- if ( nav_slaved_to_gps->getBoolValue() ) {
- value = gps_from_flag->getBoolValue();
- } else if ( nav_inrange->getBoolValue()
- && nav_serviceable->getBoolValue()
- && tofrom_serviceable->getBoolValue() )
+ if ( nav_slaved_to_gps_node->getBoolValue() ) {
+ value = gps_from_flag_node->getBoolValue();
+ } else if ( inrange_node->getBoolValue()
+ && nav_serviceable_node->getBoolValue()
+ && tofrom_serviceable_node->getBoolValue() )
{
- if ( nav_loc->getBoolValue() ) {
+ if ( loc_node->getBoolValue() ) {
value = false;
} else {
value = !(offset > 90.0 && offset < 270.0);
}
}
- nav_from_flag->setBoolValue( value );
+ from_flag_node->setBoolValue( value );
// compute the deflection of the CDI needle, clamped to the range
// of ( -10 , 10 )
- double r;
- if ( nav_slaved_to_gps->getBoolValue() ) {
- r = gps_cdi_deflection->getDoubleValue();
+ double r = 0.0;
+ if ( nav_slaved_to_gps_node->getBoolValue() ) {
+ r = gps_cdi_deflection_node->getDoubleValue();
// We want +- 5 dots deflection for the gps, so clamp to -12.5/12.5
if ( r < -12.5 ) { r = -12.5; }
if ( r > 12.5 ) { r = 12.5; }
- } else if ( nav_inrange->getBoolValue() && nav_serviceable->getBoolValue()
- && cdi_serviceable->getBoolValue()
- && !nav_slaved_to_gps->getBoolValue() )
+ } else if ( inrange_node->getBoolValue()
+ && nav_serviceable_node->getBoolValue()
+ && cdi_serviceable_node->getBoolValue() )
{
- r = nav_radial->getDoubleValue() - nav_target_radial;
+ r = radial_node->getDoubleValue() - nav_target_radial;
// cout << "Target radial = " << nav_target_radial
- // << " Actual radial = " << nav_radial->getDoubleValue() << endl;
+ // << " Actual radial = " << radial_node->getDoubleValue()
+ // << endl;
while ( r > 180.0 ) { r -= 360.0;}
while ( r < -180.0 ) { r += 360.0;}
// According to Robin Peel, the ILS is 4x more sensitive than a vor
r = -r; // reverse, since radial is outbound
- if ( nav_loc->getBoolValue() ) { r *= 4.0; }
+ if ( loc_node->getBoolValue() ) { r *= 4.0; }
if ( r < -10.0 ) { r = -10.0; }
if ( r > 10.0 ) { r = 10.0; }
} else {
r = 0.0;
}
- nav_cdi_deflection->setDoubleValue( r );
+ cdi_deflection_node->setDoubleValue( r );
// compute the amount of cross track distance error in meters
- double m;
- if ( nav_inrange->getBoolValue()
- && nav_serviceable->getBoolValue() && cdi_serviceable->getBoolValue() )
+ double m = 0.0;
+ if ( inrange_node->getBoolValue()
+ && nav_serviceable_node->getBoolValue()
+ && cdi_serviceable_node->getBoolValue() )
{
- r = nav_radial->getDoubleValue() - nav_target_radial;
+ r = radial_node->getDoubleValue() - nav_target_radial;
// cout << "Target radial = " << nav_target_radial
- // << " Actual radial = " << nav_radial->getDoubleValue()
+ // << " Actual radial = " << radial_node->getDoubleValue()
// << " r = " << r << endl;
while ( r > 180.0 ) { r -= 360.0;}
r = -r; // reverse, since radial is outbound
- m = nav_loc_dist->getDoubleValue() * sin(r * SGD_DEGREES_TO_RADIANS);
+ m = loc_dist_node->getDoubleValue() * sin(r * SGD_DEGREES_TO_RADIANS);
} else {
m = 0.0;
}
- nav_cdi_xtrack_error->setDoubleValue( m );
+ cdi_xtrack_error_node->setDoubleValue( m );
// compute the amount of glide slope needle deflection (.i.e. the
// number of degrees we are off the glide slope * 5.0
- if ( nav_inrange->getBoolValue() && nav_has_gs->getBoolValue()
- && nav_serviceable->getBoolValue()
- && gs_serviceable->getBoolValue()
- && !nav_slaved_to_gps->getBoolValue() )
+ r = 0.0;
+ if ( nav_slaved_to_gps_node->getBoolValue() ) {
+ // FIXME, what should be set here?
+ } else if ( inrange_node->getBoolValue() && has_gs_node->getBoolValue()
+ && nav_serviceable_node->getBoolValue()
+ && gs_serviceable_node->getBoolValue() )
{
- double x = nav_gs_dist->getDoubleValue();
+ double x = gs_dist_node->getDoubleValue();
double y = (fgGetDouble("/position/altitude-ft") - nav_elev)
* SG_FEET_TO_METER;
// cout << "dist = " << x << " height = " << y << endl;
double angle = asin( y / x ) * SGD_RADIANS_TO_DEGREES;
r = (nav_target_gs - angle) * 5.0;
- } else {
- r = 0.0;
}
- nav_gs_deflection->setDoubleValue( r );
+ gs_deflection_node->setDoubleValue( r );
// audio effects
if ( nav_valid
- && nav_inrange->getBoolValue()
- && nav_serviceable->getBoolValue() )
+ && inrange_node->getBoolValue()
+ && nav_serviceable_node->getBoolValue() )
{
// play station ident via audio system if on + ident,
// otherwise turn it off
- if ( power_btn->getBoolValue() && (bus_power->getDoubleValue() > 1.0)
- && nav_ident_btn->getBoolValue() && audio_btn->getBoolValue() )
+ if ( power_btn_node->getBoolValue()
+ && (bus_power_node->getDoubleValue() > 1.0)
+ && ident_btn_node->getBoolValue()
+ && audio_btn_node->getBoolValue() )
{
SGSoundSample *sound;
sound = globals->get_soundmgr()->find( nav_fx_name );
- double vol = nav_vol_btn->getDoubleValue();
+ double vol = vol_btn_node->getDoubleValue();
if ( vol < 0.0 ) { vol = 0.0; }
if ( vol > 1.0 ) { vol = 1.0; }
if ( sound != NULL ) {
// Nav.
////////////////////////////////////////////////////////////////////////
- double freq = nav_freq->getDoubleValue();
+ double freq = freq_node->getDoubleValue();
nav = globals->get_navlist()->findByFreq(freq, lon, lat, elev);
dme = globals->get_dmelist()->findByFreq(freq, lon, lat, elev);
if ( nav == NULL ) {
}
if ( loc != NULL ) {
- nav_id->setStringValue( loc->get_ident() );
- // cout << "localizer = " << nav_id->getStringValue() << endl;
+ id_node->setStringValue( loc->get_ident() );
+ // cout << "localizer = " << id_node->getStringValue() << endl;
nav_valid = true;
- if ( last_nav_id != nav_id->getStringValue() || last_nav_vor ) {
+ if ( last_id != id_node->getStringValue() || last_nav_vor ) {
nav_trans_ident = loc->get_trans_ident();
nav_target_radial = loc->get_multiuse();
while ( nav_target_radial < 0.0 ) { nav_target_radial += 360.0; }
nav_x = loc->get_x();
nav_y = loc->get_y();
nav_z = loc->get_z();
- last_nav_id = nav_id->getStringValue();
+ last_id = id_node->getStringValue();
last_nav_vor = false;
- nav_loc->setBoolValue( true );
+ loc_node->setBoolValue( true );
nav_has_dme = (dme != NULL);
- nav_has_gs->setBoolValue( gs != NULL );
- if ( nav_has_gs->getBoolValue() ) {
+ has_gs_node->setBoolValue( gs != NULL );
+ if ( has_gs_node->getBoolValue() ) {
nav_gslon = gs->get_lon();
nav_gslat = gs->get_lat();
nav_elev = gs->get_elev_ft();
nav_target_radial + 90,
100.0, &tlat, &tlon, &taz );
// cout << "nav_target_radial = " << nav_target_radial << endl;
- // cout << "nav_loc = " << nav_loc->getBoolValue() << endl;
+ // cout << "nav_loc = " << loc_node->getBoolValue() << endl;
// cout << nav_gslon << "," << nav_gslat << " "
// << tlon << "," << tlat << " (" << nav_elev << ")"
// << endl;
// cout << " id = " << loc->get_locident() << endl;
}
} else if ( nav != NULL ) {
- nav_id->setStringValue( nav->get_ident() );
- // cout << "nav = " << nav_id->getStringValue() << endl;
+ id_node->setStringValue( nav->get_ident() );
+ // cout << "nav = " << id_node->getStringValue() << endl;
nav_valid = true;
- if ( last_nav_id != nav_id->getStringValue() || !last_nav_vor ) {
- last_nav_id = nav_id->getStringValue();
+ if ( last_id != id_node->getStringValue() || !last_nav_vor ) {
+ last_id = id_node->getStringValue();
last_nav_vor = true;
nav_trans_ident = nav->get_trans_ident();
- nav_loc->setBoolValue( false );
+ loc_node->setBoolValue( false );
nav_has_dme = (dme != NULL);
- nav_has_gs->setBoolValue( false );
+ has_gs_node->setBoolValue( false );
nav_loclon = nav->get_lon();
nav_loclat = nav->get_lat();
nav_elev = nav->get_elev_ft();
nav_range = nav->get_range();
nav_effective_range = adjustNavRange(nav_elev, elev, nav_range);
nav_target_gs = 0.0;
- nav_target_radial = nav_sel_radial->getDoubleValue();
+ nav_target_radial = sel_radial_node->getDoubleValue();
nav_x = nav->get_x();
nav_y = nav->get_y();
nav_z = nav->get_z();
}
} else {
nav_valid = false;
- nav_id->setStringValue( "" );
+ id_node->setStringValue( "" );
nav_target_radial = 0;
nav_trans_ident = "";
- last_nav_id = "";
+ last_id = "";
if ( ! globals->get_soundmgr()->remove( nav_fx_name ) ) {
SG_LOG(SG_COCKPIT, SG_WARN, "Failed to remove nav-vor-ident sound");
}
}
char tmpid[5];
- strncpy( tmpid, nav_id->getStringValue(), 5 );
- nav_id_c1->setIntValue( (int)tmpid[0] );
- nav_id_c2->setIntValue( (int)tmpid[1] );
- nav_id_c3->setIntValue( (int)tmpid[2] );
- nav_id_c4->setIntValue( (int)tmpid[3] );
+ strncpy( tmpid, id_node->getStringValue(), 5 );
+ id_c1_node->setIntValue( (int)tmpid[0] );
+ id_c2_node->setIntValue( (int)tmpid[1] );
+ id_c3_node->setIntValue( (int)tmpid[2] );
+ id_c4_node->setIntValue( (int)tmpid[3] );
}
SGPropertyNode *lon_node;
SGPropertyNode *lat_node;
SGPropertyNode *alt_node;
- SGPropertyNode *bus_power;
+ SGPropertyNode *bus_power_node;
// inputs
- SGPropertyNode *power_btn;
- SGPropertyNode *nav_freq; // primary freq
- SGPropertyNode *nav_alt_freq; // standby freq
- SGPropertyNode *nav_sel_radial; // selected radial
- SGPropertyNode *nav_vol_btn;
- SGPropertyNode *nav_ident_btn;
- SGPropertyNode *audio_btn;
+ SGPropertyNode *power_btn_node;
+ SGPropertyNode *freq_node; // primary freq
+ SGPropertyNode *alt_freq_node; // standby freq
+ SGPropertyNode *sel_radial_node; // selected radial
+ SGPropertyNode *vol_btn_node;
+ SGPropertyNode *ident_btn_node;
+ SGPropertyNode *audio_btn_node;
// outputs
- SGPropertyNode *fmt_freq; // formated frequency
- SGPropertyNode *fmt_alt_freq; // formated alternate frequency
- SGPropertyNode *nav_heading; // true heading to nav station
- SGPropertyNode *nav_radial; // current radial we are on (taking
- // into consideration the vor station
- // alignment which likely doesn't
- // match the magnetic alignment
- // exactly.)
- SGPropertyNode *reciprocal_radial;
- // nav_radial + 180 (convenience value)
- SGPropertyNode *nav_target_radial_true;
- // true heading of selected radial
- SGPropertyNode *nav_target_auto_hdg;
- SGPropertyNode *nav_to_flag;
- SGPropertyNode *nav_from_flag;
- SGPropertyNode *nav_inrange;
- SGPropertyNode *nav_cdi_deflection;
- SGPropertyNode *nav_cdi_xtrack_error;
- SGPropertyNode *nav_has_gs;
- SGPropertyNode *nav_loc;
- SGPropertyNode *nav_loc_dist;
- SGPropertyNode *nav_gs_deflection;
- SGPropertyNode *nav_gs_rate_of_climb;
- SGPropertyNode *nav_gs_dist;
- SGPropertyNode *nav_id;
- SGPropertyNode *nav_id_c1;
- SGPropertyNode *nav_id_c2;
- SGPropertyNode *nav_id_c3;
- SGPropertyNode *nav_id_c4;
+ SGPropertyNode *fmt_freq_node; // formated frequency
+ SGPropertyNode *fmt_alt_freq_node; // formated alternate frequency
+ SGPropertyNode *heading_node; // true heading to nav station
+ SGPropertyNode *radial_node; // current radial we are on (taking
+ // into consideration the vor station
+ // alignment which likely doesn't
+ // match the magnetic alignment
+ // exactly.)
+ SGPropertyNode *recip_radial_node; // radial_node(val) + 180 (for
+ // convenience)
+ SGPropertyNode *target_radial_true_node;
+ // true heading of selected radial
+ SGPropertyNode *target_auto_hdg_node;
+ SGPropertyNode *to_flag_node;
+ SGPropertyNode *from_flag_node;
+ SGPropertyNode *inrange_node;
+ SGPropertyNode *cdi_deflection_node;
+ SGPropertyNode *cdi_xtrack_error_node;
+ SGPropertyNode *has_gs_node;
+ SGPropertyNode *loc_node;
+ SGPropertyNode *loc_dist_node;
+ SGPropertyNode *gs_deflection_node;
+ SGPropertyNode *gs_rate_of_climb_node;
+ SGPropertyNode *gs_dist_node;
+ SGPropertyNode *id_node;
+ SGPropertyNode *id_c1_node;
+ SGPropertyNode *id_c2_node;
+ SGPropertyNode *id_c3_node;
+ SGPropertyNode *id_c4_node;
// unfiled
- SGPropertyNode *nav_serviceable;
- SGPropertyNode *cdi_serviceable, *gs_serviceable, *tofrom_serviceable;
- SGPropertyNode *nav_slaved_to_gps;
- SGPropertyNode *gps_cdi_deflection, *gps_to_flag, *gps_from_flag;
-
- string last_nav_id;
+ SGPropertyNode *nav_serviceable_node;
+ SGPropertyNode *cdi_serviceable_node;
+ SGPropertyNode *gs_serviceable_node;
+ SGPropertyNode *tofrom_serviceable_node;
+ SGPropertyNode *nav_slaved_to_gps_node;
+ SGPropertyNode *gps_cdi_deflection_node;
+ SGPropertyNode *gps_to_flag_node;
+ SGPropertyNode *gps_from_flag_node;
+
+ string last_id;
bool last_nav_vor;
int nav_play_count;
time_t nav_last_time;
// Update nav/adf radios based on current postition
void search ();
-/*
- inline void set_bind_index( int i ) {
- index = i;
- sprintf( nav_fx_name, "nav%d-vor-ident", index );
- sprintf( dme_fx_name, "dme%d-vor-ident", index );
- }
-*/
// NavCom Accessors
inline bool has_power() const {
- return power_btn->getBoolValue() && (bus_power->getDoubleValue() > 1.0);
- }
-
- // NAV Accessors
- inline double get_nav_target_radial() const { return nav_target_radial; }
-
- // Calculated values.
- bool get_nav_to_flag () const;
- inline bool get_nav_has_dme() const { return nav_has_dme; }
- inline bool get_nav_dme_inrange () const {
- return nav_inrange->getBoolValue() && nav_has_dme;
+ return power_btn_node->getBoolValue()
+ && (bus_power_node->getDoubleValue() > 1.0);
}
- inline double get_nav_loclon() const { return nav_loclon; }
- inline double get_nav_loclat() const { return nav_loclat; }
- inline double get_nav_gslon() const { return nav_gslon; }
- inline double get_nav_gslat() const { return nav_gslat; }
- inline double get_nav_gs_dist_signed() const { return nav_gs_dist_signed; }
- inline double get_nav_elev() const { return nav_elev; }
- inline double get_nav_target_gs() const { return nav_target_gs; }
- inline double get_nav_twist() const { return nav_twist; }
- //inline const char * get_nav_id() const { return nav_id.c_str(); }
- //inline int get_nav_id_c1() const { return nav_id.c_str()[0]; }
- //inline int get_nav_id_c2() const { return nav_id.c_str()[1]; }
- //inline int get_nav_id_c3() const { return nav_id.c_str()[2]; }
- //inline int get_nav_id_c4() const { return nav_id.c_str()[3]; }
};
projects / flightgear.git / commitdiff