#include <Cockpit/radiostack.hxx>
#include <Controls/controls.hxx>
#include <FDM/flight.hxx>
-#include <Main/bfi.hxx>
#include <Main/globals.hxx>
#include <Scenery/scenery.hxx>
#include "newauto.hxx"
+#define DEFAULT_AP_HEADING_LOCK FGAutopilot::FG_DG_HEADING_LOCK
+
FGAutopilot *current_autopilot;
// constructor
FGAutopilot::FGAutopilot():
-TargetClimbRate(1000 * SG_FEET_TO_METER)
+TargetClimbRate(500 * SG_FEET_TO_METER),
+TargetDecentRate(1000 * SG_FEET_TO_METER)
{
}
static inline double get_ground_speed() {
// starts in ft/s so we convert to kts
+ static const SGPropertyNode * speedup_node = fgGetNode("/sim/speed-up");
+
double ft_s = cur_fdm_state->get_V_ground_speed()
- * fgGetInt("/sim/speed-up"); // FIXME: inefficient
+ * speedup_node->getIntValue();
double kts = ft_s * SG_FEET_TO_METER * 3600 * SG_METER_TO_NM;
return kts;
void FGAutopilot::init() {
SG_LOG( SG_AUTOPILOT, SG_INFO, "Init AutoPilot Subsystem" );
+ latitude_node = fgGetNode("/position/latitude", true);
+ longitude_node = fgGetNode("/position/longitude", true);
+ altitude_node = fgGetNode("/position/altitude", true);
+ altitude_agl_node = fgGetNode("/position/altitude-agl", true);
+ vertical_speed_node = fgGetNode("/velocities/vertical-speed", true);
+ heading_node = fgGetNode("/orientation/heading", true);
+ roll_node = fgGetNode("/orientation/roll", true);
+
heading_hold = false ; // turn the heading hold off
altitude_hold = false ; // turn the altitude hold off
auto_throttle = false ; // turn the auto throttle off
+ heading_mode = DEFAULT_AP_HEADING_LOCK;
sg_srandom_time();
DGTargetHeading = sg_random() * 360.0;
// Initialize target location to startup location
- old_lat = FGBFI::getLatitude();
- old_lon = FGBFI::getLongitude();
+ old_lat = latitude_node->getDoubleValue();
+ old_lon = longitude_node->getDoubleValue();
// set_WayPoint( old_lon, old_lat, 0.0, "default" );
MakeTargetLatLonStr( get_TargetLatitude(), get_TargetLongitude() );
alt_error_accum = 0.0;
climb_error_accum = 0.0;
- MakeTargetAltitudeStr( 3000.0);
- MakeTargetHeadingStr( 0.0 );
+ MakeTargetAltitudeStr( TargetAltitude );
+ MakeTargetHeadingStr( TargetHeading );
// These eventually need to be read from current_aircaft somehow.
heading_hold = false ; // turn the heading hold off
altitude_hold = false ; // turn the altitude hold off
auto_throttle = false ; // turn the auto throttle off
+ heading_mode = DEFAULT_AP_HEADING_LOCK;
- TargetHeading = 0.0; // default direction, due north
+ // TargetHeading = 0.0; // default direction, due north
MakeTargetHeadingStr( TargetHeading );
- TargetAltitude = 3000; // default altitude in meters
+ // TargetAltitude = 3000; // default altitude in meters
MakeTargetAltitudeStr( TargetAltitude );
alt_error_accum = 0.0;
sprintf( NewTgtAirportId, "%s", fgGetString("/sim/startup/airport-id").c_str() );
- // TargetLatitude = FGBFI::getLatitude();
- // TargetLongitude = FGBFI::getLongitude();
- // set_WayPoint( FGBFI::getLongitude(), FGBFI::getLatitude(), 0.0, "reset" );
-
MakeTargetLatLonStr( get_TargetLatitude(), get_TargetLongitude() );
}
// passing in the data pointer
// get control settings
- // double aileron = FGBFI::getAileron();
- // double elevator = FGBFI::getElevator();
- // double elevator_trim = FGBFI::getElevatorTrim();
- // double rudder = FGBFI::getRudder();
- double lat = FGBFI::getLatitude();
- double lon = FGBFI::getLongitude();
- double alt = FGBFI::getAltitude() * SG_FEET_TO_METER;
+ double lat = latitude_node->getDoubleValue();
+ double lon = longitude_node->getDoubleValue();
+ double alt = altitude_node->getDoubleValue() * SG_FEET_TO_METER;
#ifdef FG_FORCE_AUTO_DISENGAGE
// see if somebody else has changed them
// coordinator zero'd
} else if ( heading_mode == FG_TRUE_HEADING_LOCK ) {
// leave "true" target heading as is
+ while ( TargetHeading < 0.0 ) { TargetHeading += 360.0; }
+ while ( TargetHeading > 360.0 ) { TargetHeading -= 360.0; }
+ MakeTargetHeadingStr( TargetHeading );
} else if ( heading_mode == FG_HEADING_NAV1 ) {
// track the NAV1 heading needle deflection
// end of the line
heading_mode = FG_TRUE_HEADING_LOCK;
// use current heading
- TargetHeading = FGBFI::getHeading();
+ TargetHeading = heading_node->getDoubleValue();
}
}
MakeTargetHeadingStr( TargetHeading );
double AileronSet;
RelHeading
- = NormalizeDegrees( TargetHeading - FGBFI::getHeading() );
+ = NormalizeDegrees( TargetHeading
+ - heading_node->getDoubleValue() );
// figure out how far off we are from desired heading
// Now it is time to deterime how far we should be rolled.
SG_LOG( SG_COCKPIT, SG_BULK, "TargetRoll: " << TargetRoll );
- RelRoll = NormalizeDegrees( TargetRoll - FGBFI::getRoll() );
+ RelRoll = NormalizeDegrees( TargetRoll
+ - roll_node->getDoubleValue() );
// Check if we are further from heading than the roll out
// smooth point
double prop_adj, int_adj, total_adj;
if ( altitude_mode == FG_ALTITUDE_LOCK ) {
- // normal altitude hold
- // cout << "TargetAltitude = " << TargetAltitude
- // << "Altitude = " << FGBFI::getAltitude() * SG_FEET_TO_METER
- // << endl;
climb_rate =
( TargetAltitude - FGSteam::get_ALT_ft() * SG_FEET_TO_METER ) * 8.0;
} else if ( altitude_mode == FG_ALTITUDE_GS1 ) {
double x = current_radiostack->get_nav1_gs_dist();
- double y = (FGBFI::getAltitude()
+ double y = (altitude_node->getDoubleValue()
- current_radiostack->get_nav1_elev()) * SG_FEET_TO_METER;
double current_angle = atan2( y, x ) * SGD_RADIANS_TO_DEGREES;
// cout << "current angle = " << current_angle << endl;
} else if ( altitude_mode == FG_ALTITUDE_TERRAIN ) {
// brain dead ground hugging with no look ahead
climb_rate =
- ( TargetAGL - FGBFI::getAGL()*SG_FEET_TO_METER ) * 16.0;
+ ( TargetAGL - altitude_agl_node->getDoubleValue()
+ * SG_FEET_TO_METER ) * 16.0;
// cout << "target agl = " << TargetAGL
// << " current agl = " << fgAPget_agl()
// << " target climb rate = " << climb_rate
climb_rate = max_climb;
}
- if ( climb_rate < -fabs(TargetClimbRate) ) {
- climb_rate = -fabs(TargetClimbRate);
+ if ( climb_rate < -fabs(TargetDecentRate) ) {
+ climb_rate = -fabs(TargetDecentRate);
}
+
// cout << "Target climb rate = " << TargetClimbRate << endl;
// cout << "given our speed, modified desired climb rate = "
// << climb_rate * SG_METER_TO_FEET
// << " fpm" << endl;
+ // cout << "Current climb rate = "
+ // << vertical_speed_node->getDoubleValue() * 60 << " fpm" << endl;
- error = FGBFI::getVerticalSpeed() * SG_FEET_TO_METER - climb_rate;
- // cout << "climb rate = " << FGBFI::getVerticalSpeed()
- // << " vsi rate = " << FGSteam::get_VSI_fps() << endl;
+ error = vertical_speed_node->getDoubleValue() * 60
+ - climb_rate * SG_METER_TO_FEET;
// accumulate the error under the curve ... this really should
// be *= delta t
// set autopilot to hold a zero turn (as reported by the TC)
} else if ( heading_mode == FG_TRUE_HEADING_LOCK ) {
// set heading hold to current heading
- TargetHeading = FGBFI::getHeading();
+ TargetHeading = heading_node->getDoubleValue();
} else if ( heading_mode == FG_HEADING_WAYPOINT ) {
if ( globals->get_route()->size() ) {
double course, distance;
- old_lat = FGBFI::getLatitude();
- old_lon = FGBFI::getLongitude();
+ old_lat = latitude_node->getDoubleValue();
+ old_lon = longitude_node->getDoubleValue();
waypoint = globals->get_route()->get_first();
- waypoint.CourseAndDistance( FGBFI::getLongitude(),
- FGBFI::getLatitude(),
- FGBFI::getLatitude() * SG_FEET_TO_METER,
+ waypoint.CourseAndDistance( longitude_node->getDoubleValue(),
+ latitude_node->getDoubleValue(),
+ altitude_node->getDoubleValue()
+ * SG_FEET_TO_METER,
&course, &distance );
TargetHeading = course;
TargetDistance = distance;
} else {
// no more way points, default to heading lock.
heading_mode = FG_TC_HEADING_LOCK;
- // TargetHeading = FGBFI::getHeading();
}
}
alt_error_accum = 0.0;
if ( altitude_mode == FG_ALTITUDE_LOCK ) {
- if ( TargetAltitude < FGBFI::getAGL() * SG_FEET_TO_METER ) {
- // TargetAltitude = FGBFI::getAltitude() * SG_FEET_TO_METER;
+ if ( TargetAltitude < altitude_agl_node->getDoubleValue()
+ * SG_FEET_TO_METER ) {
}
if ( fgGetString("/sim/startup/units") == "feet" ) {
climb_error_accum = 0.0;
} else if ( altitude_mode == FG_ALTITUDE_TERRAIN ) {
- TargetAGL = FGBFI::getAGL() * SG_FEET_TO_METER;
+ TargetAGL = altitude_agl_node->getDoubleValue() * SG_FEET_TO_METER;
if ( fgGetString("/sim/startup/units") == "feet" ) {
MakeTargetAltitudeStr( TargetAGL * SG_METER_TO_FEET );
void FGAutopilot::HeadingSet( double new_heading ) {
- heading_mode = FG_DG_HEADING_LOCK;
-
- new_heading = NormalizeDegrees( new_heading );
- DGTargetHeading = new_heading;
- // following cast needed ambiguous plib
- // ApHeadingDialogInput -> setValue ((float)APData->TargetHeading );
- MakeTargetHeadingStr( DGTargetHeading );
+ if( heading_mode == FG_TRUE_HEADING_LOCK ) {
+ new_heading = NormalizeDegrees( new_heading );
+ TargetHeading = new_heading;
+ MakeTargetHeadingStr( TargetHeading );
+ } else {
+ heading_mode = FG_DG_HEADING_LOCK;
+
+ new_heading = NormalizeDegrees( new_heading );
+ DGTargetHeading = new_heading;
+ // following cast needed ambiguous plib
+ // ApHeadingDialogInput -> setValue ((float)APData->TargetHeading );
+ MakeTargetHeadingStr( DGTargetHeading );
+ }
update_old_control_values();
}
auto_throttle = value;
if ( auto_throttle == true ) {
- TargetSpeed = FGBFI::getAirspeed();
+ TargetSpeed = fgGetDouble("/velocities/airspeed");
speed_error_accum = 0.0;
}