//
// Written by Curtis Olson, started May 1997.
//
-// Copyright (C) 1997 Curtis L. Olson - curt@infoplane.com
+// Copyright (C) 1997 Curtis L. Olson - http://www.flightgear.org/~curt
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
*/
-#include <simgear/compiler.h>
-
#include <math.h>
#include <list>
#include <vector>
#include <string>
+#include <simgear/compiler.h>
#include <simgear/constants.h>
-#include <simgear/timing/timestamp.hxx>
-
-#include <Main/fgfs.hxx>
+#include <simgear/structure/subsystem_mgr.hxx>
+#include <FDM/groundcache.hxx>
SG_USING_STD(list);
SG_USING_STD(vector);
SG_USING_STD(string);
-
typedef double FG_VECTOR_3[3];
-
-class FGEngInterface {
-
-private:
-
- // inputs
- double Throttle;
- double Mixture;
- double Prop_Advance;
-// int Magnetos; // 0=off, 1=left, 2=right, 3=both
-// bool Starter; // flag to indicate the starter switch is on
-
- // outputs
- double RPM;
- double Manifold_Pressure; //inches
- double MaxHP;
- double Percentage_Power; //HP
- double EGT; //deg F
- double CHT; //deg F
- double prop_thrust; //lbs
- double Fuel_Flow; //Gals/hr
- double Oil_Temp; //deg F
- double Oil_Pressure; //PSI
- bool running; //flag to indicate the engine is running self-sustained
- bool cranking; //flag to indicate the engine is being turned by the starter
-
- /* others...
- double PercentN1,N1; //GE,CFM
- double PercentN2,N2;
- double EPR; //P&W, RR?
- double FuelFlow;
- bool AfterBurner;
- double InletAngles[3];
- double InletPosition[3];
- double ThrustVector[3];
- */
-
-public:
- FGEngInterface(void);
- ~FGEngInterface(void);
-
- inline double get_Throttle() const { return Throttle; }
- inline double get_Mixture() const { return Mixture; }
- inline double get_Prop_Advance() const { return Prop_Advance; }
- inline double get_RPM() const { return RPM; }
- inline double get_Manifold_Pressure() const { return Manifold_Pressure; }
- inline double get_MaxHP() const { return MaxHP; }
- inline double get_Percentage_Power() const { return Percentage_Power; }
- inline double get_EGT() const { return EGT; }
- inline double get_CHT() const { return CHT; }
- inline double get_prop_thrust() const { return prop_thrust; }
- inline double get_Fuel_Flow() const { return Fuel_Flow; }
- inline double get_Oil_Temp() const { return Oil_Temp; }
- inline double get_Oil_Pressure() const { return Oil_Pressure; }
- inline bool get_Running_Flag() const { return running; }
- inline bool get_Cranking_Flag() const { return cranking; }
-
- inline void set_Throttle( double t ) { Throttle = t; }
- inline void set_Mixture( double m ) { Mixture = m; }
- inline void set_Prop_Advance( double p ) { Prop_Advance = p; }
- inline void set_RPM( double r ) { RPM = r; }
- inline void set_Manifold_Pressure( double mp ) { Manifold_Pressure = mp; }
- inline void set_MaxHP( double hp ) { MaxHP = hp; }
- inline void set_Percentage_Power( double p ) { Percentage_Power = p; }
- inline void set_EGT( double e ) { EGT = e; }
- inline void set_CHT( double c ) { CHT = c; }
- inline void set_prop_thrust( double t ) { prop_thrust = t; }
- inline void set_Fuel_Flow( double f ) { Fuel_Flow = f; }
- inline void set_Oil_Temp (double o) { Oil_Temp = o; }
- inline void set_Running_Flag (bool r) { running = r; }
- inline void set_Cranking_Flag (bool c) { cranking = c; }
-
-};
-
-typedef vector < FGEngInterface > engine_list;
-
-
// This is based heavily on LaRCsim/ls_generic.h
-class FGInterface : public FGSubsystem {
+class FGInterface : public SGSubsystem {
private:
+ // Has the init() method been called. This is used to delay
+ // initialization until scenery can be loaded and we know the true
+ // ground elevation.
+ bool inited;
+
+ // Have we bound to the property system
+ bool bound;
+
// periodic update management variable. This is a scheme to run
// the fdm with a fixed delta-t. We control how many iteration of
// the fdm to run with the fixed dt based on the elapsed time from
// next elapsed time. This yields a small amount of temporal
// jitter ( < dt ) but in practice seems to work well.
- double delta_t; // delta "t"
- SGTimeStamp time_stamp; // time stamp of last run
- long elapsed; // time elapsed since last run
- long remainder; // remainder time from last run
- int multi_loop; // number of iterations of "delta_t" to run
+// double delta_t; // delta "t"
+// SGTimeStamp time_stamp; // time stamp of last run
+// long elapsed; // time elapsed since last run
+ double remainder; // remainder time from last run
+// int multi_loop; // number of iterations of "delta_t" to run
// Pilot location rel to ref pt
FG_VECTOR_3 d_pilot_rp_body_v;
double sin_longitude, cos_longitude;
double sin_latitude, cos_latitude;
double altitude_agl;
- double Tank1Fuel; // Gals
- double Tank2Fuel; // Gals
double daux[16]; // auxilliary doubles
float faux[16]; // auxilliary floats
int iaux[16]; // auxilliary ints
- // Engine list
- engine_list engines;
-
// SGTimeStamp valid_stamp; // time this record is valid
// SGTimeStamp next_stamp; // time this record is valid
-// protected:
+ // the ground cache object itself.
+ FGGroundCache ground_cache;
+
+protected:
+
+ int _calc_multiloop (double dt);
+
public:
// deliberately not virtual so that
void _setup();
void _busdump(void);
- void _updatePosition( double lat_geoc, double lon, double alt );
+ void _updateGeodeticPosition( double lat, double lon, double alt );
+ void _updateGeocentricPosition( double lat_geoc, double lon, double alt );
void _updateWeather( void );
inline void _set_Inertias( double m, double xx, double yy,
virtual void init ();
virtual void bind ();
virtual void unbind ();
- virtual void update ();
- virtual bool update( int multi_loop );
+ virtual void update(double dt);
virtual bool ToggleDataLogging(bool state) { return false; }
virtual bool ToggleDataLogging(void) { return false; }
FG_EXTERNAL = 10
};
+ // initialization
+ inline bool get_inited() const { return inited; }
+ inline void set_inited( bool value ) { inited = value; }
+
+ inline bool get_bound() const { return bound; }
+
+ //perform initializion that is common to all FDM's
+ void common_init();
+
// time and update management values
- inline double get_delta_t() const { return delta_t; }
- inline void set_delta_t( double dt ) { delta_t = dt; }
- inline SGTimeStamp get_time_stamp() const { return time_stamp; }
- inline void set_time_stamp( SGTimeStamp s ) { time_stamp = s; }
- inline void stamp() { time_stamp.stamp(); }
- inline long get_elapsed() const { return elapsed; }
- inline void set_elapsed( long e ) { elapsed = e; }
- inline long get_remainder() const { return remainder; }
- inline void set_remainder( long r ) { remainder = r; }
- inline int get_multi_loop() const { return multi_loop; }
- inline void set_multi_loop( int ml ) { multi_loop = ml; }
+// inline double get_delta_t() const { return delta_t; }
+// inline void set_delta_t( double dt ) { delta_t = dt; }
+// inline SGTimeStamp get_time_stamp() const { return time_stamp; }
+// inline void set_time_stamp( SGTimeStamp s ) { time_stamp = s; }
+// inline void stamp() { time_stamp.stamp(); }
+// inline long get_elapsed() const { return elapsed; }
+// inline void set_elapsed( long e ) { elapsed = e; }
+// inline long get_remainder() const { return remainder; }
+// inline void set_remainder( long r ) { remainder = r; }
+// inline int get_multi_loop() const { return multi_loop; }
+// inline void set_multi_loop( int ml ) { multi_loop = ml; }
// Positions
virtual void set_Latitude(double lat); // geocentric
virtual void set_Psi (double psi) {
set_Euler_Angles(get_Phi(), get_Theta(), psi);
}
- virtual void set_Phi_deg (double phi) { set_Phi(phi * SGD_DEGREES_TO_RADIANS); }
+ virtual void set_Phi_deg (double phi) {
+ set_Phi(phi * SGD_DEGREES_TO_RADIANS);
+ }
virtual void set_Theta_deg (double theta) {
set_Theta(theta * SGD_DEGREES_TO_RADIANS);
}
- virtual void set_Psi_deg (double psi) { set_Psi(psi * SGD_DEGREES_TO_RADIANS); }
+ virtual void set_Psi_deg (double psi) {
+ set_Psi(psi * SGD_DEGREES_TO_RADIANS);
+ }
// Flight Path
virtual void set_Climb_Rate( double roc);
virtual void set_Gamma_vert_rad( double gamma);
// Earth
- virtual void set_Sea_level_radius(double slr);
- virtual void set_Runway_altitude(double ralt);
virtual void set_Static_pressure(double p);
virtual void set_Static_temperature(double T);
double weast,
double wdown );
- // Consumables
- inline void set_Tank1Fuel( double f ) { Tank1Fuel = f; }
- inline void set_Tank2Fuel( double f ) { Tank2Fuel = f; }
-
- inline void reduce_Tank1Fuel( double f ) {
- Tank1Fuel -= f;
- if(Tank1Fuel < 0)
- Tank1Fuel = 0;
- }
- inline void reduce_Tank2Fuel( double f ) {
- Tank2Fuel -= f;
- if(Tank2Fuel < 0)
- Tank2Fuel = 0;
- }
-
-
// ========== Mass properties and geometry values ==========
// Inertias
// n_pilot_body_v[2] = z;
// }
- inline double get_Nlf(void) { return nlf; }
+ inline double get_Nlf(void) const { return nlf; }
// inline double * get_Omega_dot_body_v() { return omega_dot_body_v; }
// inline double get_P_dot_body() const { return omega_dot_body_v[0]; }
inline double get_V_rel_wind() const { return v_rel_wind; }
// inline void set_V_rel_wind(double wind) { v_rel_wind = wind; }
- // inline double get_V_true_kts() const { return v_true_kts; }
+ inline double get_V_true_kts() const { return v_true_kts; }
// inline void set_V_true_kts(double kts) { v_true_kts = kts; }
// inline double get_V_rel_ground() const { return v_rel_ground; }
inline double get_Phi_dot() const { return euler_rates_v[0]; }
inline double get_Theta_dot() const { return euler_rates_v[1]; }
inline double get_Psi_dot() const { return euler_rates_v[2]; }
+ inline double get_Phi_dot_degps() const { return euler_rates_v[0] * SGD_RADIANS_TO_DEGREES; }
+ inline double get_Theta_dot_degps() const { return euler_rates_v[1] * SGD_RADIANS_TO_DEGREES; }
+ inline double get_Psi_dot_degps() const { return euler_rates_v[2] * SGD_RADIANS_TO_DEGREES; }
// inline double * get_Geocentric_rates_v() { return geocentric_rates_v; }
inline double get_Latitude_dot() const { return geocentric_rates_v[0]; }
// }
inline double get_Alpha() const { return alpha; }
+ inline double get_Alpha_deg() const { return alpha * SGD_RADIANS_TO_DEGREES; }
inline double get_Beta() const { return beta; }
- // inline double get_Alpha_dot() const { return alpha_dot; }
+ inline double get_Beta_deg() const { return beta * SGD_RADIANS_TO_DEGREES; }
+ inline double get_Alpha_dot() const { return alpha_dot; }
// inline void set_Alpha_dot( double ad ) { alpha_dot = ad; }
- // inline double get_Beta_dot() const { return beta_dot; }
+ inline double get_Beta_dot() const { return beta_dot; }
// inline void set_Beta_dot( double bd ) { beta_dot = bd; }
// inline double get_Cos_alpha() const { return cos_alpha; }
inline double get_Mach_number() const { return mach_number; }
inline double get_Static_pressure() const { return static_pressure; }
- // inline double get_Total_pressure() const { return total_pressure; }
+ inline double get_Total_pressure() const { return total_pressure; }
// inline void set_Total_pressure( double tp ) { total_pressure = tp; }
// inline double get_Impact_pressure() const { return impact_pressure; }
// inline void set_Impact_pressure( double ip ) { impact_pressure = ip; }
- // inline double get_Dynamic_pressure() const { return dynamic_pressure; }
+ inline double get_Dynamic_pressure() const { return dynamic_pressure; }
// inline void set_Dynamic_pressure( double dp ) { dynamic_pressure = dp; }
inline double get_Static_temperature() const { return static_temperature; }
- // inline double get_Total_temperature() const { return total_temperature; }
+ inline double get_Total_temperature() const { return total_temperature; }
// inline void set_Total_temperature( double t ) { total_temperature = t; }
inline double get_Sea_level_radius() const { return sea_level_radius; }
}
inline double get_Runway_altitude() const { return runway_altitude; }
+ inline double get_Runway_altitude_m() const { return SG_FEET_TO_METER * runway_altitude; }
// inline double get_Runway_latitude() const { return runway_latitude; }
// inline void set_Runway_latitude( double lat ) { runway_latitude = lat; }
// inline double get_Runway_longitude() const { return runway_longitude; }
inline float get_faux( int n ) const { return faux[n]; }
inline int get_iaux( int n ) const { return iaux[n]; }
- // Consumables
- inline double get_Tank1Fuel() const { return Tank1Fuel; }
- inline double get_Tank2Fuel() const { return Tank2Fuel; }
+ // Note that currently this is the "same" value runway altitude...
+ inline double get_ground_elev_ft() const { return runway_altitude; }
- // engines
- inline double get_num_engines() const {
- return engines.size();
- }
- inline FGEngInterface* get_engine( int i ) {
- return &engines[i];
- }
+ //////////////////////////////////////////////////////////////////////////
+ // Ground handling routines
+ //////////////////////////////////////////////////////////////////////////
- inline void add_engine( FGEngInterface e ) {
- engines.push_back( e );
- }
-};
+ enum GroundType {
+ Unknown = 0, //??
+ Solid, // Whatever we will roll on with infinite load factor.
+ Forest, // Ground unsuitable for taxiing.
+ Water, // For the beaver ...
+ Catapult, // Carrier cats.
+ Wire // Carrier wires.
+ };
+ // Prepare the ground cache for the wgs84 position pt_*.
+ // That is take all vertices in the ball with radius rad around the
+ // position given by the pt_* and store them in a local scene graph.
+ bool prepare_ground_cache_m(double ref_time, const double pt[3],
+ double rad);
+ bool prepare_ground_cache_ft(double ref_time, const double pt[3],
+ double rad);
+
+
+ // Returns true if the cache is valid.
+ // Also the reference time, point and radius values where the cache
+ // is valid for are returned.
+ bool is_valid_m(double *ref_time, double pt[3], double *rad);
+ bool is_valid_ft(double *ref_time, double pt[3], double *rad);
+
+ // Return the nearest catapult to the given point
+ // pt in wgs84 coordinates.
+ double get_cat_m(double t, const double pt[3],
+ double end[2][3], double vel[2][3]);
+ double get_cat_ft(double t, const double pt[3],
+ double end[2][3], double vel[2][3]);
+
-typedef list < FGInterface > fdm_state_list;
-typedef fdm_state_list::iterator fdm_state_list_iterator;
-typedef fdm_state_list::const_iterator const_fdm_state_list_iterator;
+ // Return the altitude above ground below the wgs84 point pt
+ // Search for the nearest triangle to pt.
+ // Return ground properties like the ground type, the maximum load
+ // this kind kind of ground can carry, the friction factor between
+ // 0 and 1 which can be used to model lower friction with wet runways
+ // and finally the altitude above ground.
+ bool get_agl_m(double t, const double pt[3],
+ double contact[3], double normal[3], double vel[3],
+ int *type, double *loadCapacity,
+ double *frictionFactor, double *agl);
+ bool get_agl_ft(double t, const double pt[3],
+ double contact[3], double normal[3], double vel[3],
+ int *type, double *loadCapacity,
+ double *frictionFactor, double *agl);
+ bool get_agl_m(double t, const double pt[3], double max_altoff,
+ double contact[3], double normal[3], double vel[3],
+ int *type, double *loadCapacity,
+ double *frictionFactor, double *agl);
+ bool get_agl_ft(double t, const double pt[3], double max_altoff,
+ double contact[3], double normal[3], double vel[3],
+ int *type, double *loadCapacity,
+ double *frictionFactor, double *agl);
+ double get_groundlevel_m(double lat, double lon, double alt);
+
+
+ // Return 1 if the hook intersects with a wire.
+ // That test is done by checking if the quad spanned by the points pt*
+ // intersects with the line representing the wire.
+ // If the wire is caught, the cache will trace this wires endpoints until
+ // the FDM calls release_wire().
+ bool caught_wire_m(double t, const double pt[4][3]);
+ bool caught_wire_ft(double t, const double pt[4][3]);
+
+ // Return the location and speed of the wire endpoints.
+ bool get_wire_ends_m(double t, double end[2][3], double vel[2][3]);
+ bool get_wire_ends_ft(double t, double end[2][3], double vel[2][3]);
+ // Tell the cache code that it does no longer need to care for
+ // the wire end position.
+ void release_wire(void);
+};
extern FGInterface * cur_fdm_state;
-
-// General interface to the flight model routines
-
-// Set the altitude (force)
-void fgFDMForceAltitude(const string &model, double alt_meters);
-
-// Set the local ground elevation
-void fgFDMSetGroundElevation(const string &model, double alt_meters);
-
// Toggle data logging on/off
void fgToggleFDMdataLogging(void);
projects / flightgear.git / blobdiff