X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FInstrumentation%2Fnavradio.cxx;h=4bfe15d48f9fc9071740c3471934c3d671d52dfc;hb=4265b2e2419bd9da2d6e83851c9bd0ab3e41fdb0;hp=eacb7a6d67fe27d2d6fb3bc55c9fb32659f47766;hpb=d784810430050457365d203fb453042ba17582cf;p=flightgear.git diff --git a/src/Instrumentation/navradio.cxx b/src/Instrumentation/navradio.cxx index eacb7a6d6..4bfe15d48 100644 --- a/src/Instrumentation/navradio.cxx +++ b/src/Instrumentation/navradio.cxx @@ -78,58 +78,22 @@ static SGVec3d tangentVector(const SGGeod& tail, const SGVec3d& tail_xyz, return (head_xyz - tail_xyz) * (1.0/fudge); } +// Create a "serviceable" node with a default value of "true" +SGPropertyNode_ptr createServiceableProp(SGPropertyNode* aParent, const char* aName) +{ + SGPropertyNode_ptr n = (aParent->getChild(aName, 0, true)->getChild("serviceable", 0, true)); + simgear::props::Type typ = n->getType(); + if ((typ == simgear::props::NONE) || (typ == simgear::props::UNSPECIFIED)) { + n->setBoolValue(true); + } + return n; +} + // Constructor FGNavRadio::FGNavRadio(SGPropertyNode *node) : lon_node(fgGetNode("/position/longitude-deg", true)), lat_node(fgGetNode("/position/latitude-deg", true)), alt_node(fgGetNode("/position/altitude-ft", true)), - is_valid_node(NULL), - power_btn_node(NULL), - freq_node(NULL), - alt_freq_node(NULL), - sel_radial_node(NULL), - vol_btn_node(NULL), - ident_btn_node(NULL), - audio_btn_node(NULL), - backcourse_node(NULL), - nav_serviceable_node(NULL), - cdi_serviceable_node(NULL), - gs_serviceable_node(NULL), - tofrom_serviceable_node(NULL), - fmt_freq_node(NULL), - fmt_alt_freq_node(NULL), - heading_node(NULL), - radial_node(NULL), - recip_radial_node(NULL), - target_radial_true_node(NULL), - target_auto_hdg_node(NULL), - time_to_intercept(NULL), - to_flag_node(NULL), - from_flag_node(NULL), - inrange_node(NULL), - signal_quality_norm_node(NULL), - cdi_deflection_node(NULL), - cdi_deflection_norm_node(NULL), - cdi_xtrack_error_node(NULL), - cdi_xtrack_hdg_err_node(NULL), - has_gs_node(NULL), - loc_node(NULL), - loc_dist_node(NULL), - gs_deflection_node(NULL), - gs_deflection_deg_node(NULL), - gs_deflection_norm_node(NULL), - gs_rate_of_climb_node(NULL), - gs_dist_node(NULL), - nav_id_node(NULL), - id_c1_node(NULL), - id_c2_node(NULL), - id_c3_node(NULL), - id_c4_node(NULL), - nav_slaved_to_gps_node(NULL), - gps_cdi_deflection_node(NULL), - gps_to_flag_node(NULL), - gps_from_flag_node(NULL), - gps_has_gs_node(NULL), play_count(0), last_time(0), target_radial(0.0), @@ -137,10 +101,12 @@ FGNavRadio::FGNavRadio(SGPropertyNode *node) : last_x(0.0), last_loc_dist(0.0), last_xtrack_error(0.0), + xrate_ms(0.0), _localizerWidth(5.0), _name(node->getStringValue("name", "nav")), _num(node->getIntValue("number", 0)), - _time_before_search_sec(-1.0) + _time_before_search_sec(-1.0), + _sgr(NULL) { SGPath path( globals->get_fg_root() ); SGPath term = path; @@ -153,12 +119,19 @@ FGNavRadio::FGNavRadio(SGPropertyNode *node) : term_tbl = new SGInterpTable( term.str() ); low_tbl = new SGInterpTable( low.str() ); high_tbl = new SGInterpTable( high.str() ); + + + string branch("/instrumentation/" + _name); + _radio_node = fgGetNode(branch.c_str(), _num, true); } // Destructor FGNavRadio::~FGNavRadio() { + gps_course_node->removeChangeListener(this); + nav_slaved_to_gps_node->removeChangeListener(this); + delete term_tbl; delete low_tbl; delete high_tbl; @@ -168,13 +141,13 @@ FGNavRadio::~FGNavRadio() void FGNavRadio::init () { - morse.init(); - - string branch; - branch = "/instrumentation/" + _name; + SGSoundMgr *smgr = globals->get_soundmgr(); + _sgr = smgr->find("avionics", true); + _sgr->tie_to_listener(); - SGPropertyNode *node = fgGetNode(branch.c_str(), _num, true ); + morse.init(); + SGPropertyNode* node = _radio_node.get(); bus_power_node = fgGetNode(("/systems/electrical/outputs/" + _name).c_str(), true); @@ -189,13 +162,20 @@ FGNavRadio::init () audio_btn_node->setBoolValue( true ); backcourse_node = node->getChild("back-course-btn", 0, true); backcourse_node->setBoolValue( false ); + nav_serviceable_node = node->getChild("serviceable", 0, true); - cdi_serviceable_node = (node->getChild("cdi", 0, true)) - ->getChild("serviceable", 0, true); - gs_serviceable_node = (node->getChild("gs", 0, true)) - ->getChild("serviceable"); - tofrom_serviceable_node = (node->getChild("to-from", 0, true)) - ->getChild("serviceable", 0, true); + cdi_serviceable_node = createServiceableProp(node, "cdi"); + gs_serviceable_node = createServiceableProp(node, "gs"); + tofrom_serviceable_node = createServiceableProp(node, "to-from"); + dme_serviceable_node = createServiceableProp(node, "dme"); + + falseCoursesEnabledNode = + fgGetNode("/sim/realism/false-radio-courses-enabled"); + if (!falseCoursesEnabledNode) { + falseCoursesEnabledNode = + fgGetNode("/sim/realism/false-radio-courses-enabled", true); + falseCoursesEnabledNode->setBoolValue(true); + } // frequencies SGPropertyNode *subnode = node->getChild("frequencies", 0, true); @@ -231,7 +211,10 @@ FGNavRadio::init () gs_deflection_deg_node = node->getChild("gs-needle-deflection-deg", 0, true); gs_deflection_norm_node = node->getChild("gs-needle-deflection-norm", 0, true); gs_rate_of_climb_node = node->getChild("gs-rate-of-climb", 0, true); + gs_rate_of_climb_fpm_node = node->getChild("gs-rate-of-climb-fpm", 0, true); gs_dist_node = node->getChild("gs-distance", 0, true); + gs_inrange_node = node->getChild("gs-in-range", 0, true); + nav_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); @@ -240,11 +223,17 @@ FGNavRadio::init () // gps slaving support nav_slaved_to_gps_node = node->getChild("slaved-to-gps", 0, true); + nav_slaved_to_gps_node->addChangeListener(this); + 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); gps_has_gs_node = fgGetNode("/instrumentation/gps/has-gs", true); - gps_course_node = fgGetNode("/instrumentation/gps/selected-course-deg", true); + gps_course_node = fgGetNode("/instrumentation/gps/desired-course-deg", true); + gps_course_node->addChangeListener(this); + + gps_xtrack_error_nm_node = fgGetNode("/instrumentation/gps/wp/wp[1]/course-error-nm", true); + _magvarNode = fgGetNode("/environment/magnetic-variation-deg", true); std::ostringstream temp; temp << _name << "nav-ident" << _num; @@ -256,20 +245,18 @@ FGNavRadio::init () void FGNavRadio::bind () { - std::ostringstream temp; - string branch; - temp << _num; - branch = "/instrumentation/" + _name + "[" + temp.str() + "]"; + tie("dme-in-range", SGRawValuePointer(&_dmeInRange)); + tie("operable", SGRawValueMethods(*this, &FGNavRadio::isOperable, NULL)); } void FGNavRadio::unbind () { - std::ostringstream temp; - string branch; - temp << _num; - branch = "/instrumentation/" + _name + "[" + temp.str() + "]"; + for (unsigned int t=0; t<_tiedNodes.size(); ++t) { + _tiedNodes[t]->untie(); + } + _tiedNodes.clear(); } @@ -277,6 +264,10 @@ FGNavRadio::unbind () double FGNavRadio::adjustNavRange( double stationElev, double aircraftElev, double nominalRange ) { + if (nominalRange <= 0.0) { + nominalRange = FG_NAV_DEFAULT_RANGE; + } + // extend out actual usable range to be 1.3x the published safe range const double usability_factor = 1.3; @@ -357,7 +348,8 @@ FGNavRadio::update(double dt) if (power_btn_node->getBoolValue() && (bus_power_node->getDoubleValue() > 1.0) && nav_serviceable_node->getBoolValue() ) - { + { + _operable = true; if (nav_slaved_to_gps_node->getBoolValue()) { updateGPSSlaved(); } else { @@ -383,9 +375,13 @@ void FGNavRadio::clearOutputs() gs_deflection_node->setDoubleValue( 0.0 ); gs_deflection_deg_node->setDoubleValue(0.0); gs_deflection_norm_node->setDoubleValue(0.0); + gs_inrange_node->setBoolValue( false ); to_flag_node->setBoolValue( false ); from_flag_node->setBoolValue( false ); + + _dmeInRange = false; + _operable = false; } void FGNavRadio::updateReceiver(double dt) @@ -459,7 +455,7 @@ void FGNavRadio::updateReceiver(double dt) effective_range = adjustNavRange( nav_elev, pos.getElevationM(), _navaid->get_range() ); } - + double effective_range_m = effective_range * SG_NM_TO_METER; ////////////////////////////////////////////////////////// @@ -503,12 +499,28 @@ void FGNavRadio::updateReceiver(double dt) SG_NORMALIZE_RANGE(r, -180.0, 180.0); if ( is_loc ) { - // The factor of 30.0 gives a period of 120 which gives us 3 cycles and six - // zeros i.e. six courses: one front course, one back course, and four - // false courses. Three of the six are reverse sensing. - _cdiDeflection = 30.0 * sawtooth(r / 30.0); + if (falseCoursesEnabledNode->getBoolValue()) { + // The factor of 30.0 gives a period of 120 which gives us 3 cycles and six + // zeros i.e. six courses: one front course, one back course, and four + // false courses. Three of the six are reverse sensing. + _cdiDeflection = 30.0 * sawtooth(r / 30.0); + } else { + // no false courses, but we do need to create a back course + if (fabs(r) > 90.0) { // front course + _cdiDeflection = r - copysign(180.0, r); + } else { + _cdiDeflection = r; // back course + } + + _cdiDeflection = -_cdiDeflection; // reverse for outbound radial + } // of false courses disabled + const double VOR_FULL_ARC = 20.0; // VOR is -10 .. 10 degree swing _cdiDeflection *= VOR_FULL_ARC / _localizerWidth; // increased localiser sensitivity + + if (backcourse_node->getBoolValue()) { + _cdiDeflection = -_cdiDeflection; + } } else { // handle the TO side of the VOR if (fabs(r) > 90.0) { @@ -524,6 +536,7 @@ void FGNavRadio::updateReceiver(double dt) _cdiCrossTrackErrorM = loc_dist * sin(r * SGD_DEGREES_TO_RADIANS); updateGlideSlope(dt, aircraft, signal_quality_norm); + updateDME(aircraft); last_loc_dist = loc_dist; } @@ -533,12 +546,20 @@ void FGNavRadio::updateGlideSlope(double dt, const SGVec3d& aircraft, double sig _gsNeedleDeflection = 0.0; if (!_gs || !inrange_node->getBoolValue()) { gs_dist_node->setDoubleValue( 0.0 ); + gs_inrange_node->setBoolValue(false); + _gsNeedleDeflection = 0.0; + _gsNeedleDeflectionNorm = 0.0; return; } double gsDist = dist(aircraft, _gsCart); gs_dist_node->setDoubleValue(gsDist); - if (gsDist > (_gs->get_range() * SG_NM_TO_METER)) { + bool gsInRange = (gsDist < (_gs->get_range() * SG_NM_TO_METER)); + gs_inrange_node->setBoolValue(gsInRange); + + if (!gsInRange) { + _gsNeedleDeflection = 0.0; + _gsNeedleDeflectionNorm = 0.0; return; } @@ -549,21 +570,23 @@ void FGNavRadio::updateGlideSlope(double dt, const SGVec3d& aircraft, double sig double dot_v = dot(pos, _gsVertical); double angle = atan2(dot_v, dot_h) * SGD_RADIANS_TO_DEGREES; double deflectionAngle = target_gs - angle; - - // Construct false glideslopes. The scale factor of 1.5 - // in the sawtooth gives a period of 6 degrees. - // There will be zeros at 3, 6r, 9, 12r et cetera - // where "r" indicates reverse sensing. - // This is is consistent with conventional pilot lore - // e.g. http://www.allstar.fiu.edu/aerojava/ILS.htm - // but inconsistent with - // http://www.freepatentsonline.com/3757338.html - // - // It may be that some of each exist. - if (deflectionAngle < 0) { - deflectionAngle = 1.5 * sawtooth(deflectionAngle / 1.5); - } else { - // no false GS below the true GS + + if (falseCoursesEnabledNode->getBoolValue()) { + // Construct false glideslopes. The scale factor of 1.5 + // in the sawtooth gives a period of 6 degrees. + // There will be zeros at 3, 6r, 9, 12r et cetera + // where "r" indicates reverse sensing. + // This is is consistent with conventional pilot lore + // e.g. http://www.allstar.fiu.edu/aerojava/ILS.htm + // but inconsistent with + // http://www.freepatentsonline.com/3757338.html + // + // It may be that some of each exist. + if (deflectionAngle < 0) { + deflectionAngle = 1.5 * sawtooth(deflectionAngle / 1.5); + } else { + // no false GS below the true GS + } } _gsNeedleDeflection = deflectionAngle * 5.0; @@ -578,17 +601,53 @@ void FGNavRadio::updateGlideSlope(double dt, const SGVec3d& aircraft, double sig double gs_diff = target_gs - angle; // convert desired vertical path angle into a climb rate double des_angle = angle - 10 * gs_diff; + /* printf("target_gs=%.1f angle=%.1f gs_diff=%.1f des_angle=%.1f\n", + target_gs, angle, gs_diff, des_angle); */ // estimate horizontal speed towards ILS in meters per minute double elapsedDistance = last_x - gsDist; last_x = gsDist; double new_vel = ( elapsedDistance / dt ); - horiz_vel = 0.75 * horiz_vel + 0.25 * new_vel; + horiz_vel = 0.99 * horiz_vel + 0.01 * new_vel; + /* printf("vel=%.1f (dist=%.1f dt=%.2f)\n", horiz_vel, elapsedDistance, dt);*/ gs_rate_of_climb_node ->setDoubleValue( -sin( des_angle * SGD_DEGREES_TO_RADIANS ) * horiz_vel * SG_METER_TO_FEET ); + gs_rate_of_climb_fpm_node + ->setDoubleValue( gs_rate_of_climb_node->getDoubleValue() * 60 ); +} + +void FGNavRadio::updateDME(const SGVec3d& aircraft) +{ + if (!_dme || !dme_serviceable_node->getBoolValue()) { + _dmeInRange = false; + return; + } + + double dme_distance = dist(aircraft, _dme->cart()); + _dmeInRange = (dme_distance < _dme->get_range() * SG_NM_TO_METER); +} + +void FGNavRadio::valueChanged (SGPropertyNode* prop) +{ + if (prop == gps_course_node) { + if (!nav_slaved_to_gps_node->getBoolValue()) { + return; + } + + // GPS desired course has changed, sync up our selected-course + double v = prop->getDoubleValue(); + if (v != sel_radial_node->getDoubleValue()) { + sel_radial_node->setDoubleValue(v); + } + } else if (prop == nav_slaved_to_gps_node) { + if (prop->getBoolValue()) { + // slaved-to-GPS activated, sync up selected course + sel_radial_node->setDoubleValue(gps_course_node->getDoubleValue()); + } + } } void FGNavRadio::updateGPSSlaved() @@ -598,16 +657,30 @@ void FGNavRadio::updateGPSSlaved() _toFlag = gps_to_flag_node->getBoolValue(); _fromFlag = gps_from_flag_node->getBoolValue(); - inrange_node->setBoolValue(_toFlag | _fromFlag); + bool gpsValid = (_toFlag | _fromFlag); + inrange_node->setBoolValue(gpsValid); + if (!gpsValid) { + signal_quality_norm_node->setDoubleValue(0.0); + _cdiDeflection = 0.0; + _cdiCrossTrackErrorM = 0.0; + _gsNeedleDeflection = 0.0; + return; + } + + // this is unfortunate, but panel instruments use this value to decide + // if the navradio output is valid. + signal_quality_norm_node->setDoubleValue(1.0); _cdiDeflection = gps_cdi_deflection_node->getDoubleValue(); // clmap to some range (+/- 10 degrees) as the regular deflection SG_CLAMP_RANGE(_cdiDeflection, -10.0, 10.0 ); - _cdiCrossTrackErrorM = 0.0; // FIXME, supply this + _cdiCrossTrackErrorM = gps_xtrack_error_nm_node->getDoubleValue() * SG_NM_TO_METER; _gsNeedleDeflection = 0.0; // FIXME, supply this - //sel_radial_node->setDoubleValue(gps_course_node->getDoubleValue()); + double trtrue = gps_course_node->getDoubleValue() + _magvarNode->getDoubleValue(); + SG_NORMALIZE_RANGE(trtrue, 0.0, 360.0); + target_radial_true_node->setDoubleValue( trtrue ); } void FGNavRadio::updateCDI(double dt) @@ -689,7 +762,8 @@ void FGNavRadio::updateCDI(double dt) ////////////////////////////////////////////////////////// double t = 0.0; if ( inrange && cdi_serviceable ) { - double xrate_ms = (last_xtrack_error - _cdiCrossTrackErrorM) / dt; + double cur_rate = (last_xtrack_error - _cdiCrossTrackErrorM) / dt; + xrate_ms = 0.99 * xrate_ms + 0.01 * cur_rate; if ( fabs(xrate_ms) > 0.00001 ) { t = _cdiCrossTrackErrorM / xrate_ms; } else { @@ -717,17 +791,17 @@ void FGNavRadio::updateAudio() // play station ident via audio system if on + ident, // otherwise turn it off - if (!power_btn_node->getBoolValue() + if (!power_btn_node->getBoolValue() || !(bus_power_node->getDoubleValue() > 1.0) || !ident_btn_node->getBoolValue() || !audio_btn_node->getBoolValue() ) { - globals->get_soundmgr()->stop( nav_fx_name ); - globals->get_soundmgr()->stop( dme_fx_name ); + _sgr->stop( nav_fx_name ); + _sgr->stop( dme_fx_name ); return; } - SGSoundSample *sound = globals->get_soundmgr()->find( nav_fx_name ); - double vol = vol_btn_node->getDoubleValue(); + SGSoundSample *sound = _sgr->find( nav_fx_name ); + double vol = vol_btn_node->getFloatValue(); SG_CLAMP_RANGE(vol, 0.0, 1.0); if ( sound != NULL ) { @@ -736,31 +810,40 @@ void FGNavRadio::updateAudio() SG_LOG( SG_COCKPIT, SG_ALERT, "Can't find nav-vor-ident sound" ); } - sound = globals->get_soundmgr()->find( dme_fx_name ); + sound = _sgr->find( dme_fx_name ); if ( sound != NULL ) { sound->set_volume( vol ); } else { SG_LOG( SG_COCKPIT, SG_ALERT, "Can't find nav-dme-ident sound" ); } + + const int NUM_IDENT_SLOTS = 5; + const time_t SLOT_LENGTH = 5; // seconds - if ( last_time < globals->get_time_params()->get_cur_time() - 30 ) { - last_time = globals->get_time_params()->get_cur_time(); - play_count = 0; + // There are N slots numbered 0 through (NUM_IDENT_SLOTS-1) inclusive. + // Each slot is 5 seconds long. + // Slots 0 is for DME + // the rest are for azimuth. + time_t now = globals->get_time_params()->get_cur_time(); + if ((now >= last_time) && (now < last_time + SLOT_LENGTH)) { + return; // wait longer } - if ( play_count < 4 ) { - // play VOR ident - if ( !globals->get_soundmgr()->is_playing(nav_fx_name) ) { - globals->get_soundmgr()->play_once( nav_fx_name ); - ++play_count; + last_time = now; + play_count = ++play_count % NUM_IDENT_SLOTS; + + // Previous ident is out of time; if still playing, cut it off: + _sgr->stop( nav_fx_name ); + _sgr->stop( dme_fx_name ); + if (play_count == 0) { // the DME slot + if (_dmeInRange && dme_serviceable_node->getBoolValue()) { + // play DME ident + if (vol > 0.05) _sgr->play_once( dme_fx_name ); + } + } else { // NAV slot + if (inrange_node->getBoolValue() && nav_serviceable_node->getBoolValue()) { + if (vol > 0.05) _sgr->play_once(nav_fx_name); } - } else if ( play_count < 5 && has_dme) { - // play DME ident - if ( !globals->get_soundmgr()->is_playing(nav_fx_name) && - !globals->get_soundmgr()->is_playing(dme_fx_name) ) { - globals->get_soundmgr()->play_once( dme_fx_name ); - ++play_count; - } } } @@ -790,8 +873,7 @@ void FGNavRadio::search() _navaid = nav; char identBuffer[5] = " "; if (nav) { - FGNavRecord* dme = globals->get_dmelist()->findByFreq(freq, pos); - has_dme = (dme != NULL); + _dme = globals->get_dmelist()->findByFreq(freq, pos); nav_id_node->setStringValue(nav->get_ident()); strncpy(identBuffer, nav->ident().c_str(), 5); @@ -803,10 +885,11 @@ void FGNavRadio::search() if (nav->type() == FGPositioned::VOR) { target_radial = sel_radial_node->getDoubleValue(); _gs = NULL; + has_gs_node->setBoolValue(false); } else { // ILS or LOC _gs = globals->get_gslist()->findByFreq(freq, pos); - _localizerWidth = localizerWidth(nav); has_gs_node->setBoolValue(_gs != NULL); + _localizerWidth = localizerWidth(nav); twist = 0.0; effective_range = nav->get_range(); @@ -817,14 +900,22 @@ void FGNavRadio::search() int tmp = (int)(_gs->get_multiuse() / 1000.0); target_gs = (double)tmp / 100.0; + // until penaltyForNav goes away, we cannot assume we always pick + // paired LOC/GS trasmsitters. As we pass over a runway threshold, we + // often end up picking the 'wrong' LOC, but the correct GS. To avoid + // breaking the basis computation, ensure we use the GS radial and not + // the (potentially reversed) LOC radial. + double gs_radial = fmod(_gs->get_multiuse(), 1000.0); + SG_NORMALIZE_RANGE(gs_radial, 0.0, 360.0); + // GS axis unit tangent vector // (along the runway) _gsCart = _gs->cart(); - _gsAxis = tangentVector(_gs->geod(), _gsCart, target_radial); + _gsAxis = tangentVector(_gs->geod(), _gsCart, gs_radial); // GS baseline unit tangent vector // (perpendicular to the runay along the ground) - SGVec3d baseline = tangentVector(_gs->geod(), _gsCart, target_radial + 90.0); + SGVec3d baseline = tangentVector(_gs->geod(), _gsCart, gs_radial + 90.0); _gsVertical = cross(baseline, _gsAxis); } // of have glideslope } // of found LOC or ILS @@ -832,10 +923,11 @@ void FGNavRadio::search() audioNavidChanged(); } else { // found nothing _gs = NULL; + _dme = NULL; nav_id_node->setStringValue(""); - has_dme = false; - globals->get_soundmgr()->remove( nav_fx_name ); - globals->get_soundmgr()->remove( dme_fx_name ); + + _sgr->remove( nav_fx_name ); + _sgr->remove( dme_fx_name ); } is_valid_node->setBoolValue(nav != NULL); @@ -877,25 +969,25 @@ double FGNavRadio::localizerWidth(FGNavRecord* aLOC) void FGNavRadio::audioNavidChanged() { - if ( globals->get_soundmgr()->exists(nav_fx_name)) { - globals->get_soundmgr()->remove(nav_fx_name); + if (_sgr->exists(nav_fx_name)) { + _sgr->remove(nav_fx_name); } try { string trans_ident(_navaid->get_trans_ident()); SGSoundSample* sound = morse.make_ident(trans_ident, LO_FREQUENCY); sound->set_volume( 0.3 ); - if (!globals->get_soundmgr()->add( sound, nav_fx_name )) { + if (!_sgr->add( sound, nav_fx_name )) { SG_LOG(SG_COCKPIT, SG_WARN, "Failed to add v1-vor-ident sound"); } - if ( globals->get_soundmgr()->exists( dme_fx_name ) ) { - globals->get_soundmgr()->remove( dme_fx_name ); + if ( _sgr->exists( dme_fx_name ) ) { + _sgr->remove( dme_fx_name ); } sound = morse.make_ident( trans_ident, HI_FREQUENCY ); sound->set_volume( 0.3 ); - globals->get_soundmgr()->add( sound, dme_fx_name ); + _sgr->add( sound, dme_fx_name ); int offset = (int)(sg_random() * 30.0); play_count = offset / 4;