Runway Awareness and Advisory System: Difference between revisions

From FlightGear wiki
Jump to navigation Jump to search
No edit summary
m (cat)
 
(26 intermediate revisions by one other user not shown)
Line 15: Line 15:
The Runway Advisory and Awareness System can give a number of advisories:
The Runway Advisory and Awareness System can give a number of advisories:


* Advisory when approaching a runway while taxiing
{| class="wikitable"
 
|-
* Advisory when the aircraft is on the runway and pointing in the right direction for takeoff
! Feature !! RAAS
 
|-
* Advisory of remaining distance to the end of the runway during a landing
| On runway and alignment < 20 degrees || {{Progressbar|100}}
|-
| On short runway, announcing remaining distance || {{Progressbar|100}}
|-
| On runway (reminder) || {{Not done}}
|-
| Approaching runway (on ground) when groundspeed < 40 knots || {{Progressbar|100}}
|-
| Approaching runway (airborne) when distance < 3 nm, alignment < 20 degrees, AFE is 300 - 750 ft || {{Progressbar|100}}
|-
| Approaching runway (airborne), announcing available distance || {{Progressbar|100}}
|-
| Distance remaining (during landing) when AGL < 100 feet and groundspeed > 40 knots || {{Progressbar|100}}
|-
| Distance remaining after rejected takeoff, past 50 % of runway and 7 knots below maximum groundspeed || {{Progressbar|100}}
|-
| Runway end when distance remaininig < 100 feet or 30 meters and groundspeed < 40 knots || {{Progressbar|100}}
|-
| Taxiway takeoff when groundspeed > 40 knots while not on runway || {{Not done}}
|}


https://www.youtube.com/watch?feature=player_detailpage&v=59ymnKUi49A#t=117
https://www.youtube.com/watch?feature=player_detailpage&v=59ymnKUi49A#t=117
Line 25: Line 44:
https://www.youtube.com/watch?feature=player_detailpage&v=0jkRhIMZAZo#t=171
https://www.youtube.com/watch?feature=player_detailpage&v=0jkRhIMZAZo#t=171


== TODO ==
== Aircraft ==
 
* Find a core dev to commit logger.nas and runway_announcer.nas to FlightGear's fgdata repository {{Progressbar|50}}


* Use *.groundnet.xml to detect when the aircraft is near a holding point to more accurately emit "approaching-runway" signal {{Not done}}
Currently RAAS is only used in the [https://github.com/dogsaysmoo/747-8i/ 747-8i].


* Give an advisory of which runway the aircraft is lined up with when the aircraft is airborne and approaching a runway {{Not done}}
{{tip|Ask the developer of your favorite aircraft if you want it to support RAAS.}}


* Give caution of distance remaining during rejected takeoff {{Not done}}
== TODO ==


* Give "Long landing" caution when aircraft has less than a specified distance/percentage remaining {{Not done}}
{| class="wikitable"
|-
| Use *.groundnet.xml to detect when the aircraft is near a holding point to more accurately emit "approaching-runway" signal || {{Not done}}
|-
| Allow remaining-distance to be emitted while aircraft is not on ground || {{Not done}}
|-
| Allow to choose between 450 - 550 ft or 350 - 450 ft suppression of approaching-runway (in air) || {{Not done}}
|-
| Require climb rate to be < 450 ft/min for remaining-distance || {{Not done}}
|-
| Require the presence of a mk-viii (GPWS) module || {{Not done}}
|}


== Signals ==
== Signals ==
Line 47: Line 75:
! Mode !! Emitted signals
! Mode !! Emitted signals
|-
|-
| taxi-and-takeoff || approaching-runway, on-runway
| taxi-and-takeoff || approaching-runway, on-runway, on-short-runway
|-
|-
| taxi || approaching-runway
| takeoff || on-runway, on-short-runway
|-
|-
| takeoff || on-runway
| approach || approaching-runway, approaching-short-runway
|}
|}


Line 59: Line 87:
|-
|-
! Mode !! Emitted signals
! Mode !! Emitted signals
|-
| takeoff || remaining-distance, vacated-runway
|-
|-
| landing || remaining-distance, landed-runway, vacated-runway, landed-outside-runway
| landing || remaining-distance, landed-runway, vacated-runway, landed-outside-runway
Line 82: Line 112:
</syntaxhighlight>
</syntaxhighlight>


Add the file runway.nas to your aircraft's Nasal folder. The following example listens for gear[1] and gear[2] and overrides a number of properties of the takeoff_config object so that it can be used for large airliners:
Add the file runway.nas to your aircraft's Nasal folder. This file is aircraft specific and needs to be constructed using the steps below.
 
== Nasal/runway.nas ==
 
The following example listens to /gear/on-ground and overrides a number of properties of the takeoff_config object so that it can be used for large airliners.
 
=== Step 1 of 3: Functions ===
 
First, create a number of functions to format and print messages:


<syntaxhighlight lang="nasal">
<syntaxhighlight lang="nasal">
Line 102: Line 140:
var copilot_say = func (message) {
var copilot_say = func (message) {
     setprop("/sim/messages/copilot", message);
     setprop("/sim/messages/copilot", message);
    logger.info(sprintf("Announcing '%s'", message));
};
};


var make_notification_cb = func (format, action=nil) {
var on_short_runway_format = func {
     return func (data=nil) {
     var distance = getprop("/sim/runway-announcer/short-runway-distance");
        if (format != nil) {
    return sprintf("On runway %%s, %d %s remaining", distance, takeoff_config.distances_unit);
            if (data != nil) {
};
                var message = sprintf(format, data.getValue());
            }
            else {
                var message = format;
            }


            copilot_say(message);
var approaching_short_runway_format = func {
            logger.info(sprintf("Announcing '%s'", message));
    var distance = takeoff_announcer.get_short_runway_distance();
        }
    return sprintf("Approaching runway %%s, %d %s available", distance, takeoff_config.distances_unit);
};


        if (typeof(action) == "func") {
var remaining_distance_format = func {
            action();
    return sprintf("%%d %s remaining", landing_config.distances_unit);
        }
    };
};
};
</syntaxhighlight>


var stop_announcer = func {
{{tip|You might want to replace copilot_say().}}
    landing_announcer.stop();
    logger.warn("Stopping landing announce");


    takeoff_announcer.set_mode("taxi-and-takeoff");
=== Step 2 of 3: Announcers ===
};


var switch_to_takeoff = func {
Second, create configuration objects, override some of their parameters, create the announcers, and then connect the various signals to callbacks:
    # Switch to takeoff mode so that the "approaching-runway" signal
    # is not emitted for any runways that are crossed during takeoff
    if (takeoff_announcer.mode == "taxi-and-takeoff") {
        takeoff_announcer.set_mode("takeoff");
    }
};


<syntaxhighlight lang="nasal">
var takeoff_config = { parents: [runway.TakeoffRunwayAnnounceConfig] };
var takeoff_config = { parents: [runway.TakeoffRunwayAnnounceConfig] };
# You can modify this setting from a GUI during runtime
takeoff_config.distances_unit = "meter";


# Will cause the announcer to emit the "on-runway" signal if the
# Will cause the announcer to emit the "on-runway" signal if the
# aircraft is within 600 meters of the beginning of the runway and
# aircraft is at most 15 meters from the center line of the runway
# at most 15 meters from the center line of the runway
takeoff_config.distance_center_line_m = 15;
takeoff_config.distance_center_line_m = 15;
takeoff_config.distance_start_m = 600;


# Let the announcer emit the "approaching-runway" signal if the
# Let the announcer emit the "approaching-runway" signal if the
# aircraft comes within 200 meters of the runway
# nose of the aircraft comes within 120 meters of the runway
takeoff_config.distance_edge_max_m = 200;
takeoff_config.distance_edge_max_m = 150;


var takeoff_announcer = runway.TakeoffRunwayAnnounceClass.new(takeoff_config);
var landing_config = { parents: [runway.LandingRunwayAnnounceConfig] };
takeoff_announcer.connect("on-runway", make_notification_cb("On runway %s", switch_to_takeoff));
landing_config.distance_center_nose_m = 30;
takeoff_announcer.connect("approaching-runway", make_notification_cb("Approaching runway %s"));


var landing_config = { parents: [runway.LandingRunwayAnnounceConfig] };
# You can modify this setting from a GUI during runtime
landing_config.distances_unit = "meter";


# Create announcers
var takeoff_announcer = runway.TakeoffRunwayAnnounceClass.new(takeoff_config);
var landing_announcer = runway.LandingRunwayAnnounceClass.new(landing_config);
var landing_announcer = runway.LandingRunwayAnnounceClass.new(landing_config);
landing_announcer.connect("remaining-distance", make_notification_cb("%d remaining"));
landing_announcer.connect("vacated-runway", make_notification_cb("Vacated runway %s", stop_announcer));
landing_announcer.connect("landed-runway", make_notification_cb("Touchdown on runway %s"));
landing_announcer.connect("landed-outside-runway", make_notification_cb(nil, stop_announcer));


var make_switch_mode_cb = func (wow_mode, no_wow_mode) {
var stop_announcer    = runway.make_stop_announcer_func(takeoff_announcer, landing_announcer);
    return func (node) {
var switch_to_takeoff = runway.make_switch_to_takeoff_func(takeoff_announcer, landing_announcer);
        if (node.getBoolValue()) {
            if (getprop("/gear/gear[1]/wow") and getprop("/gear/gear[2]/wow")) {
                takeoff_announcer.set_mode(wow_mode);
            }
            else {
                takeoff_announcer.set_mode(no_wow_mode);
            }
        }
        else {
            takeoff_announcer.set_mode("");
        }
    };
};


setlistener("/controls/lighting/nav-lights",
takeoff_announcer.connect("on-runway", runway.make_betty_cb(copilot_say, "On runway %s", switch_to_takeoff));
  make_switch_mode_cb("taxi-and-takeoff", "taxi"),
takeoff_announcer.connect("on-short-runway", runway.make_betty_cb(copilot_say, on_short_runway_format, switch_to_takeoff));
  startup=1, runtime=0);
takeoff_announcer.connect("approaching-runway", runway.make_betty_cb(copilot_say, "Approaching runway %s"));
takeoff_announcer.connect("approaching-short-runway", runway.make_betty_cb(copilot_say, approaching_short_runway_format));


var have_been_in_air = 0;
landing_announcer.connect("remaining-distance", runway.make_betty_cb(copilot_say, remaining_distance_format));
landing_announcer.connect("vacated-runway", runway.make_betty_cb(copilot_say, "Vacated runway %s", stop_announcer));
landing_announcer.connect("landed-runway", runway.make_betty_cb(copilot_say, "Touchdown on runway %s"));
landing_announcer.connect("landed-outside-runway", runway.make_betty_cb(nil, nil, stop_announcer));
</syntaxhighlight>


var test_on_ground = func (on_ground) {
=== Step 3 of 3: Listeners ===
    if (on_ground) {
        takeoff_announcer.start();
        logger.warn("Starting takeoff announce");


        if (have_been_in_air == 1) {
Finally, set up a listener to detect when the aircraft is on the ground and when it is airborne:
            have_been_in_air = 0;


            takeoff_announcer.set_mode("");
<syntaxhighlight lang="nasal">
 
# Depending on whether the aircraft is on the ground or not, it will start, stop, or change the modes of the announcers
            landing_announcer.start();
var set_on_ground = runway.make_set_ground_func(takeoff_announcer, landing_announcer);
            landing_announcer.set_mode("landing");
            logger.warn("Starting landing announce");
        }
    }
    else {
        takeoff_announcer.stop();
        logger.warn("Stopping takeoff announce");
 
        landing_announcer.stop();
        logger.warn("Stopping landing announce");
 
        if (have_been_in_air == 0) {
            have_been_in_air = 1;
        }
    }
};


var init_announcers = func {
var init_announcers = func {
     setlistener("/gear/gear[1]/wow", func (n) {
     setlistener("/gear/on-ground", func (node) {
         test_on_ground(getprop("/gear/gear[1]/wow") and getprop("/gear/gear[2]/wow"));
         set_on_ground(node.getBoolValue());
    }, startup=1, runtime=0);
 
    setlistener("/gear/gear[2]/wow", func (n) {
        test_on_ground(getprop("/gear/gear[1]/wow") and getprop("/gear/gear[2]/wow"));
     }, startup=1, runtime=0);
     }, startup=1, runtime=0);
};
};


setlistener("/sim/signals/fdm-initialized", func {
setlistener("/sim/signals/fdm-initialized", func {
    logger.warn("FDM initialized");
     var timer = maketimer(5.0, func init_announcers());
     var timer = maketimer(5.0, func init_announcers());
     timer.singleShot = 1;
     timer.singleShot = 1;
Line 232: Line 223:
</syntaxhighlight>
</syntaxhighlight>


{{Note|In this case gear[1] and gear[2] are used to detect whether the aircraft is on the ground or in the air. You may want to modify this for your aircraft.}}
{{Note|In this example the /gear/on-ground property is used to detect whether the aircraft is on the ground or in the air. Make sure to use a <logic> element in a <autopilot> XML file to set this to true or false depending on your gears' wow values.}}


{{Note|It is your responsibility to start and stop the announcers and to set the correct modes. Therefore it is necessary to connect to signals like landed-outside-runway and vacated-runway, even if they appear to be useless for your specific aircraft. The example of runway.nas above already does this for you.}}
{{Note|It is your responsibility to start and stop the announcers and to set the correct modes. Therefore it is necessary to connect to signals like landed-outside-runway and vacated-runway, even if they appear to be useless for your specific aircraft. The example of runway.nas above already does this for you.}}


{{Note|You might want to replace copilot_say().}}
== Configuring the announcers ==


The configuration object takeoff_config has a number of properties with default values. These properties can be modified if you want to change when certain signals are emitted. For example, in the example of runway.nas above, distance_center_line_m, distance_start_m, and distance_edge_max_m where overridden for large airliners. The defaults are:
The configuration object takeoff_config has a number of properties with default values. These properties can be modified if you want to change when certain signals are emitted. For example, in the example of runway.nas above, distance_center_line_m and distance_edge_max_m where overridden for large airliners. The defaults are:


<syntaxhighlight lang="nasal">
<syntaxhighlight lang="nasal">
distance_start_m: 200,
diff_runway_heading_deg: 20,
# The maximum distance in meters from the starting position
# on the runway. Large runways are usually 40 to 60 meters wide.
 
diff_runway_heading_deg: 10,
# Difference in heading between runway and aircraft in order to
# Difference in heading between runway and aircraft in order to
# get an announcement that the aircraft is on the runway for takeoff.
# get an announcement that the aircraft is on the runway for takeoff
# or approaching while airborne.


diff_approach_heading_deg: 40,
diff_approach_heading_deg: 40,
Line 260: Line 248:
# Minimum and maximum distance in meters from the edge of the runway
# Minimum and maximum distance in meters from the edge of the runway
# for announcing approaches.
# for announcing approaches.
nominal_distance_takeoff_m: 3000,
# Minimum distance in meters required for a normal takeoff. If
# remaining distance when entering the runway is less than the distance
# required for a normal takeoff, then the on-short-runway instead of
# on-runway signal will be emitted.
nominal_distance_landing_m: 2000,
# Minimum distance in meters required for a normal landing. If
# runway length when approaching the runway is less than the distance
# required for a normal landing, then the approaching-short-runway
# instead of approaching-runway signal will be emitted.
distances_unit: "meter",
# The unit to use for the remaining distance of short runways. Can
# be "meter" or "feet".
groundspeed_max_kt: 40,
# Maximum groundspeed in knots for approaching runway callouts
approach_afe_min_ft: 300,
approach_afe_max_ft: 750,
# Minimum and maximum altitude Above Field Elevation in feet. Used to
# decide whether to announce that the aircraft is approaching a runway.
approach_distance_max_nm: 3.0,
# Maximum distance in nautical miles of the aircraft to the
# approaching runway
</syntaxhighlight>
</syntaxhighlight>


Line 265: Line 281:


<syntaxhighlight lang="nasal">
<syntaxhighlight lang="nasal">
distances: [30, 100, 300, 600, 900, 1200, 2000, 3000, 4000],
distances_meter: [100, 300, 600, 900, 1200, 1500],
 
distances_feet:  [500, 1000, 2000, 3000, 4000, 5000],
 
distances_unit: "meter",
# The unit to use for the remaining distance. Can be "meter" or "feet"
 
distance_center_nose_m: 0,
# Distance from the center to the nose in meters


diff_runway_heading_deg: 15,
diff_runway_heading_deg: 20,
# Difference in heading between runway and aircraft in order to
# Difference in heading between runway and aircraft in order to
# detect the correct runway on which the aircraft is landing.
# detect the correct runway on which the aircraft is landing.
groundspeed_min_kt: 40,
# Minimum groundspeed in knots for remaining distance callouts
agl_max_ft: 100,
# Maximum AGL in feet for remaining distance callouts
</syntaxhighlight>
</syntaxhighlight>
[[Category:Aircraft enhancement]]

Latest revision as of 08:42, 9 January 2015

Runway Awareness and Advisory System
Started in 08/2014
Description System to give advisories about runways
Contributor(s) onox
Status Under active development as of 08/2014
Subforum http://forum.flightgear.org/viewtopic.php?f=66&t=21266

Features

The Runway Advisory and Awareness System can give a number of advisories:

Feature RAAS
On runway and alignment < 20 degrees 100}% completed
On short runway, announcing remaining distance 100}% completed
On runway (reminder) Not done Not done
Approaching runway (on ground) when groundspeed < 40 knots 100}% completed
Approaching runway (airborne) when distance < 3 nm, alignment < 20 degrees, AFE is 300 - 750 ft 100}% completed
Approaching runway (airborne), announcing available distance 100}% completed
Distance remaining (during landing) when AGL < 100 feet and groundspeed > 40 knots 100}% completed
Distance remaining after rejected takeoff, past 50 % of runway and 7 knots below maximum groundspeed 100}% completed
Runway end when distance remaininig < 100 feet or 30 meters and groundspeed < 40 knots 100}% completed
Taxiway takeoff when groundspeed > 40 knots while not on runway Not done Not done

https://www.youtube.com/watch?feature=player_detailpage&v=59ymnKUi49A#t=117

https://www.youtube.com/watch?feature=player_detailpage&v=0jkRhIMZAZo#t=171

Aircraft

Currently RAAS is only used in the 747-8i.

Tip  Ask the developer of your favorite aircraft if you want it to support RAAS.

TODO

Use *.groundnet.xml to detect when the aircraft is near a holding point to more accurately emit "approaching-runway" signal Not done Not done
Allow remaining-distance to be emitted while aircraft is not on ground Not done Not done
Allow to choose between 450 - 550 ft or 350 - 450 ft suppression of approaching-runway (in air) Not done Not done
Require climb rate to be < 450 ft/min for remaining-distance Not done Not done
Require the presence of a mk-viii (GPWS) module Not done Not done

Signals

In order to give these advisories, callbacks for a number of signals can be registered to two announcers. Depending on the current mode of each announcer they will emit certain signals:

Takeoff announcer

Mode Emitted signals
taxi-and-takeoff approaching-runway, on-runway, on-short-runway
takeoff on-runway, on-short-runway
approach approaching-runway, approaching-short-runway

Landing announcer

Mode Emitted signals
takeoff remaining-distance, vacated-runway
landing remaining-distance, landed-runway, vacated-runway, landed-outside-runway

Installation

In case logger.nas and runway_announcer.nas have not been added to FlightGear's fgdata project yet, add the following to the beginning of the <nasal> element in your aircraft's -set.xml file:

<logger>
    <file>Aircraft/$YOUR_AIRCRAFT_FOLDER/Nasal/logger.nas</file>
</logger>
<runway>
    <file>Aircraft/$YOUR_AIRCRAFT_FOLDER/Nasal/runway_announcer.nas</file>
</runway>

Add the following to the <nasal> element below the previous two:

<file>Aircraft/$YOUR_AIRCRAFT_FOLDER/Nasal/runway.nas</file>

Add the file runway.nas to your aircraft's Nasal folder. This file is aircraft specific and needs to be constructed using the steps below.

Nasal/runway.nas

The following example listens to /gear/on-ground and overrides a number of properties of the takeoff_config object so that it can be used for large airliners.

Step 1 of 3: Functions

First, create a number of functions to format and print messages:

# Copyright (C) 2014  onox
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

var copilot_say = func (message) {
    setprop("/sim/messages/copilot", message);
    logger.info(sprintf("Announcing '%s'", message));
};

var on_short_runway_format = func {
    var distance = getprop("/sim/runway-announcer/short-runway-distance");
    return sprintf("On runway %%s, %d %s remaining", distance, takeoff_config.distances_unit);
};

var approaching_short_runway_format = func {
    var distance = takeoff_announcer.get_short_runway_distance();
    return sprintf("Approaching runway %%s, %d %s available", distance, takeoff_config.distances_unit);
};

var remaining_distance_format = func {
    return sprintf("%%d %s remaining", landing_config.distances_unit);
};
Tip  You might want to replace copilot_say().

Step 2 of 3: Announcers

Second, create configuration objects, override some of their parameters, create the announcers, and then connect the various signals to callbacks:

var takeoff_config = { parents: [runway.TakeoffRunwayAnnounceConfig] };

# You can modify this setting from a GUI during runtime
takeoff_config.distances_unit = "meter";

# Will cause the announcer to emit the "on-runway" signal if the
# aircraft is at most 15 meters from the center line of the runway
takeoff_config.distance_center_line_m = 15;

# Let the announcer emit the "approaching-runway" signal if the
# nose of the aircraft comes within 120 meters of the runway
takeoff_config.distance_edge_max_m = 150;

var landing_config = { parents: [runway.LandingRunwayAnnounceConfig] };
landing_config.distance_center_nose_m = 30;

# You can modify this setting from a GUI during runtime
landing_config.distances_unit = "meter";

# Create announcers
var takeoff_announcer = runway.TakeoffRunwayAnnounceClass.new(takeoff_config);
var landing_announcer = runway.LandingRunwayAnnounceClass.new(landing_config);

var stop_announcer    = runway.make_stop_announcer_func(takeoff_announcer, landing_announcer);
var switch_to_takeoff = runway.make_switch_to_takeoff_func(takeoff_announcer, landing_announcer);

takeoff_announcer.connect("on-runway", runway.make_betty_cb(copilot_say, "On runway %s", switch_to_takeoff));
takeoff_announcer.connect("on-short-runway", runway.make_betty_cb(copilot_say, on_short_runway_format, switch_to_takeoff));
takeoff_announcer.connect("approaching-runway", runway.make_betty_cb(copilot_say, "Approaching runway %s"));
takeoff_announcer.connect("approaching-short-runway", runway.make_betty_cb(copilot_say, approaching_short_runway_format));

landing_announcer.connect("remaining-distance", runway.make_betty_cb(copilot_say, remaining_distance_format));
landing_announcer.connect("vacated-runway", runway.make_betty_cb(copilot_say, "Vacated runway %s", stop_announcer));
landing_announcer.connect("landed-runway", runway.make_betty_cb(copilot_say, "Touchdown on runway %s"));
landing_announcer.connect("landed-outside-runway", runway.make_betty_cb(nil, nil, stop_announcer));

Step 3 of 3: Listeners

Finally, set up a listener to detect when the aircraft is on the ground and when it is airborne:

# Depending on whether the aircraft is on the ground or not, it will start, stop, or change the modes of the announcers
var set_on_ground = runway.make_set_ground_func(takeoff_announcer, landing_announcer);

var init_announcers = func {
    setlistener("/gear/on-ground", func (node) {
        set_on_ground(node.getBoolValue());
    }, startup=1, runtime=0);
};

setlistener("/sim/signals/fdm-initialized", func {
    var timer = maketimer(5.0, func init_announcers());
    timer.singleShot = 1;
    timer.start();
});
Note  In this example the /gear/on-ground property is used to detect whether the aircraft is on the ground or in the air. Make sure to use a <logic> element in a <autopilot> XML file to set this to true or false depending on your gears' wow values.
Note  It is your responsibility to start and stop the announcers and to set the correct modes. Therefore it is necessary to connect to signals like landed-outside-runway and vacated-runway, even if they appear to be useless for your specific aircraft. The example of runway.nas above already does this for you.

Configuring the announcers

The configuration object takeoff_config has a number of properties with default values. These properties can be modified if you want to change when certain signals are emitted. For example, in the example of runway.nas above, distance_center_line_m and distance_edge_max_m where overridden for large airliners. The defaults are:

diff_runway_heading_deg: 20,
# Difference in heading between runway and aircraft in order to
# get an announcement that the aircraft is on the runway for takeoff
# or approaching while airborne.

diff_approach_heading_deg: 40,
# Maximum angle at which the aircraft should approach the runway.
# Must be higher than 0 and lower than 90.

distance_center_line_m: 10,
# The distance in meters from the center line of the runway

distance_edge_min_m: 20,
distance_edge_max_m: 80,
# Minimum and maximum distance in meters from the edge of the runway
# for announcing approaches.

nominal_distance_takeoff_m: 3000,
# Minimum distance in meters required for a normal takeoff. If
# remaining distance when entering the runway is less than the distance
# required for a normal takeoff, then the on-short-runway instead of
# on-runway signal will be emitted.

nominal_distance_landing_m: 2000,
# Minimum distance in meters required for a normal landing. If
# runway length when approaching the runway is less than the distance
# required for a normal landing, then the approaching-short-runway
# instead of approaching-runway signal will be emitted.

distances_unit: "meter",
# The unit to use for the remaining distance of short runways. Can
# be "meter" or "feet".

groundspeed_max_kt: 40,
# Maximum groundspeed in knots for approaching runway callouts

approach_afe_min_ft: 300,
approach_afe_max_ft: 750,
# Minimum and maximum altitude Above Field Elevation in feet. Used to
# decide whether to announce that the aircraft is approaching a runway.

approach_distance_max_nm: 3.0,
# Maximum distance in nautical miles of the aircraft to the
# approaching runway

The same applies to the configuration object landing_config:

distances_meter: [100,  300,  600,  900, 1200, 1500],

distances_feet:  [500, 1000, 2000, 3000, 4000, 5000],

distances_unit: "meter",
# The unit to use for the remaining distance. Can be "meter" or "feet"

distance_center_nose_m: 0,
# Distance from the center to the nose in meters

diff_runway_heading_deg: 20,
# Difference in heading between runway and aircraft in order to
# detect the correct runway on which the aircraft is landing.

groundspeed_min_kt: 40,
# Minimum groundspeed in knots for remaining distance callouts

agl_max_ft: 100,
# Maximum AGL in feet for remaining distance callouts