fly/flightgear
1
0
Fork 0
Code Activity

First commit of properties code. JSBSim now has a basic property tree all

Browse source 
under /fdm/jsbsim
This commit is contained in:
tony 2002-03-20 12:45:02 +00:00
parent 0cc3bed841
commit 317d794f5c
40 changed files with 1771 additions and 413 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

102
src/FDM/JSBSim/FGAerodynamics.cpp
View file

@ -39,10 +39,15 @@ INCLUDES
#include "FGAerodynamics.h" #include "FGAerodynamics.h"
#include "FGFactorGroup.h" #include "FGFactorGroup.h"
#include "FGCoefficient.h" #include "FGCoefficient.h"
#include "FGPropertyManager.h"
static const char *IdSrc = "$Id$"; static const char *IdSrc = "$Id$";
static const char *IdHdr = ID_AERODYNAMICS; static const char *IdHdr = ID_AERODYNAMICS;
const unsigned NAxes=6;
const char* AxisNames[] = { "drag", "side-force", "lift", "rolling-moment",
"pitching-moment","yawing-moment" };
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
CLASS IMPLEMENTATION CLASS IMPLEMENTATION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
@ -61,6 +66,10 @@ FGAerodynamics::FGAerodynamics(FGFDMExec* FDMExec) : FGModel(FDMExec)
Coeff = new CoeffArray[6]; Coeff = new CoeffArray[6];
clsq=lod=0;
bind();
Debug(0); Debug(0);
} }
@ -69,6 +78,9 @@ FGAerodynamics::FGAerodynamics(FGFDMExec* FDMExec) : FGModel(FDMExec)
FGAerodynamics::~FGAerodynamics() FGAerodynamics::~FGAerodynamics()
{ {
unsigned int i,j; unsigned int i,j;
unbind();
for (i=0; i<6; i++) { for (i=0; i<6; i++) {
for (j=0; j<Coeff[i].size(); j++) { for (j=0; j<Coeff[i].size(); j++) {
delete Coeff[i][j]; delete Coeff[i][j];
@ -92,12 +104,25 @@ bool FGAerodynamics::Run(void)
for (axis_ctr = 0; axis_ctr < 3; axis_ctr++) { for (axis_ctr = 0; axis_ctr < 3; axis_ctr++) {
for (ctr=0; ctr < Coeff[axis_ctr].size(); ctr++) { for (ctr=0; ctr < Coeff[axis_ctr].size(); ctr++) {
//Coeff[axis_ctr][ctr]->Run();
vFs(axis_ctr+1) += Coeff[axis_ctr][ctr]->TotalValue(); vFs(axis_ctr+1) += Coeff[axis_ctr][ctr]->TotalValue();
//cout << Coeff[axis_ctr][ctr]->Getname() << "= "
// << Coeff[axis_ctr][ctr]->TotalValue() << endl;
} }
} }
//correct signs of drag and lift to wind axes convention //correct signs of drag and lift to wind axes convention
//positive forward, right, down //positive forward, right, down
vFs(1)*=-1; vFs(3)*=-1; if( Translation->Getqbar() > 0) {
clsq = vFs(eLift) / (Aircraft->GetWingArea()*Translation->Getqbar());
clsq *= clsq;
}
if ( vFs(eDrag) > 0) {
lod = vFs(eLift) / vFs(eDrag);
}
//correct signs of drag and lift to wind axes convention
//positive forward, right, down
vFs(eDrag)*=-1; vFs(eLift)*=-1;
//cout << "Aircraft::vFs: " << vFs << endl; //cout << "Aircraft::vFs: " << vFs << endl;
vForces = State->GetTs2b()*vFs; vForces = State->GetTs2b()*vFs;
@ -112,6 +137,7 @@ bool FGAerodynamics::Run(void)
for (axis_ctr = 0; axis_ctr < 3; axis_ctr++) { for (axis_ctr = 0; axis_ctr < 3; axis_ctr++) {
for (ctr = 0; ctr < Coeff[axis_ctr+3].size(); ctr++) { for (ctr = 0; ctr < Coeff[axis_ctr+3].size(); ctr++) {
//Coeff[axis_ctr+3][ctr]->Run();
vMoments(axis_ctr+1) += Coeff[axis_ctr+3][ctr]->TotalValue(); vMoments(axis_ctr+1) += Coeff[axis_ctr+3][ctr]->TotalValue();
} }
} }
@ -150,6 +176,8 @@ bool FGAerodynamics::Load(FGConfigFile* AC_cfg)
} }
} }
bindModel();
return true; return true;
} }
@ -197,11 +225,75 @@ string FGAerodynamics::GetCoefficientValues(void)
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
double FGAerodynamics::GetLoD(void) void FGAerodynamics::bind(void){
{
if (vFs(1) != 0.00) return vFs(3)/vFs(1); PropertyManager->Tie("forces/fbx-aero-lbs", this,1,
else return 0.00; &FGAerodynamics::GetForces);
PropertyManager->Tie("forces/fby-aero-lbs", this,2,
&FGAerodynamics::GetForces);
PropertyManager->Tie("forces/fbz-aero-lbs", this,3,
&FGAerodynamics::GetForces);
PropertyManager->Tie("moments/l-aero-lbsft", this,1,
&FGAerodynamics::GetMoments);
PropertyManager->Tie("moments/m-aero-lbsft", this,2,
&FGAerodynamics::GetMoments);
PropertyManager->Tie("moments/n-aero-lbsft", this,3,
&FGAerodynamics::GetMoments);
PropertyManager->Tie("forces/fwx-aero-lbs", this,1,
&FGAerodynamics::GetvFs);
PropertyManager->Tie("forces/fwy-aero-lbs", this,2,
&FGAerodynamics::GetvFs);
PropertyManager->Tie("forces/fwz-aero-lbs", this,3,
&FGAerodynamics::GetvFs);
PropertyManager->Tie("forces/lod-norm", this,
&FGAerodynamics::GetLoD);
PropertyManager->Tie("aero/cl-squared-norm", this,
&FGAerodynamics::GetClSquared);
} }
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
void FGAerodynamics::bindModel(void) {
unsigned i,j;
FGPropertyManager* node;
string prop_name;
for(i=0;i<NAxes;i++) {
for (j=0; j < Coeff[i].size(); j++) {
prop_name = "aero/buildup/" + string(AxisNames[i])
+ "/" + Coeff[i][j]->Getname();
node= PropertyManager->GetNode(prop_name,true);
Coeff[i][j]->bind(node);
}
}
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
void FGAerodynamics::unbind(void){
unsigned i,j;
PropertyManager->Untie("forces/fbx-aero-lbs");
PropertyManager->Untie("forces/fby-aero-lbs");
PropertyManager->Untie("forces/fbz-aero-lbs");
PropertyManager->Untie("moments/l-aero-lbsft");
PropertyManager->Untie("moments/m-aero-lbsft");
PropertyManager->Untie("moments/n-aero-lbsft");
PropertyManager->Untie("forces/fwx-aero-lbs");
PropertyManager->Untie("forces/fwy-aero-lbs");
PropertyManager->Untie("forces/fwz-aero-lbs");
PropertyManager->Untie("forces/lod-norm");
PropertyManager->Untie("aero/cl-squared-norm");
for( i=0; i<NAxes; i++ ) {
for ( j=0; j < Coeff[i].size(); j++ ) {
Coeff[i][j]->unbind();
}
}
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// The bitmasked value choices are as follows: // The bitmasked value choices are as follows:
// unset: In this case (the default) JSBSim would only print // unset: In this case (the default) JSBSim would only print

15
src/FDM/JSBSim/FGAerodynamics.h
View file

@ -112,18 +112,19 @@ public:
/** Gets the total aerodynamic force vector. /** Gets the total aerodynamic force vector.
@return a force vector reference. */ @return a force vector reference. */
FGColumnVector3& GetForces(void) {return vForces;} FGColumnVector3& GetForces(void) {return vForces;}
inline double GetForces(int n) {return vForces(n);} inline double GetForces(int n) const {return vForces(n);}
/** Gets the total aerodynamic moment vector. /** Gets the total aerodynamic moment vector.
@return a moment vector reference. */ @return a moment vector reference. */
FGColumnVector3& GetMoments(void) {return vMoments;} FGColumnVector3& GetMoments(void) {return vMoments;}
inline double GetMoments(int n) {return vMoments(n);} inline double GetMoments(int n) const {return vMoments(n);}
inline FGColumnVector3& GetvLastFs(void) { return vLastFs; } inline FGColumnVector3& GetvLastFs(void) { return vLastFs; }
inline double GetvLastFs(int axis) { return vLastFs(axis); } inline double GetvLastFs(int axis) const { return vLastFs(axis); }
inline FGColumnVector3& GetvFs(void) { return vFs; } inline FGColumnVector3& GetvFs(void) { return vFs; }
inline double GetvFs(int axis) { return vFs(axis); } inline double GetvFs(int axis) const { return vFs(axis); }
double GetLoD(void); inline double GetLoD(void) const { return lod; }
inline double GetClSquared(void) const { return clsq; }
/** Gets the strings for the current set of coefficients. /** Gets the strings for the current set of coefficients.
@return a string containing the descriptive names for all coefficients */ @return a string containing the descriptive names for all coefficients */
@ -136,6 +137,9 @@ public:
inline FGCoefficient* GetCoefficient(string name) { return cm[name]; } inline FGCoefficient* GetCoefficient(string name) { return cm[name]; }
void bind(void);
void bindModel(void);
void unbind(void);
private: private:
typedef map<string,int> AxisIndex; typedef map<string,int> AxisIndex;
@ -149,6 +153,7 @@ private:
FGColumnVector3 vMoments; FGColumnVector3 vMoments;
FGColumnVector3 vLastFs; FGColumnVector3 vLastFs;
FGColumnVector3 vDXYZcg; FGColumnVector3 vDXYZcg;
double clsq,lod;
void Debug(int from); void Debug(int from);
}; };

116
src/FDM/JSBSim/FGAircraft.cpp
View file

@ -82,6 +82,7 @@ INCLUDES
#include "FGPosition.h" #include "FGPosition.h"
#include "FGAuxiliary.h" #include "FGAuxiliary.h"
#include "FGOutput.h" #include "FGOutput.h"
#include "FGPropertyManager.h"
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
DEFINITIONS DEFINITIONS
@ -100,12 +101,16 @@ CLASS IMPLEMENTATION
FGAircraft::FGAircraft(FGFDMExec* fdmex) : FGModel(fdmex) FGAircraft::FGAircraft(FGFDMExec* fdmex) : FGModel(fdmex)
{ {
Name = "FGAircraft"; Name = "FGAircraft";
alphaclmin = alphaclmax = 0; alphaclmin = alphaclmax = 0;
HTailArea = VTailArea = HTailArm = VTailArm = 0.0; HTailArea = VTailArea = HTailArm = VTailArm = 0.0;
lbarh = lbarv = vbarh = vbarv = 0.0; lbarh = lbarv = vbarh = vbarv = 0.0;
WingIncidence=0; WingIncidence=0;
impending_stall = 0; impending_stall = 0;
bi2vel=ci2vel=alphaw=0;
bind();
Debug(0); Debug(0);
} }
@ -114,6 +119,7 @@ FGAircraft::FGAircraft(FGFDMExec* fdmex) : FGModel(fdmex)
FGAircraft::~FGAircraft() FGAircraft::~FGAircraft()
{ {
unbind();
Debug(1); Debug(1);
} }
@ -121,6 +127,8 @@ FGAircraft::~FGAircraft()
bool FGAircraft::Run(void) bool FGAircraft::Run(void)
{ {
double twovel;
if (!FGModel::Run()) { // if false then execute this Run() if (!FGModel::Run()) { // if false then execute this Run()
vForces.InitMatrix(); vForces.InitMatrix();
vForces += Aerodynamics->GetForces(); vForces += Aerodynamics->GetForces();
@ -140,6 +148,14 @@ bool FGAircraft::Run(void)
vNwcg = State->GetTb2s() * vNcg; vNwcg = State->GetTb2s() * vNcg;
vNwcg(3) = -1*vNwcg(3) + 1; vNwcg(3) = -1*vNwcg(3) + 1;
twovel=2*Translation->GetVt();
if(twovel > 0) {
bi2vel = WingSpan / twovel;
ci2vel = cbar / twovel;
}
alphaw = Translation->Getalpha() + WingIncidence;
if (alphaclmax != 0) { if (alphaclmax != 0) {
if (Translation->Getalpha() > 0.85*alphaclmax) { if (Translation->Getalpha() > 0.85*alphaclmax) {
impending_stall = 10*(Translation->Getalpha()/alphaclmax - 0.85); impending_stall = 10*(Translation->Getalpha()/alphaclmax - 0.85);
@ -240,6 +256,7 @@ bool FGAircraft::Load(FGConfigFile* AC_cfg)
<< endl; << endl;
} else if (parameter == "AC_POINTMASS") { } else if (parameter == "AC_POINTMASS") {
*AC_cfg >> pmWt >> pmX >> pmY >> pmZ; *AC_cfg >> pmWt >> pmX >> pmY >> pmZ;
MassBalance->AddPointMass(pmWt, pmX, pmY, pmZ);
if (debug_lvl > 0) cout << " Point Mass Object: " << pmWt << " lbs. at " if (debug_lvl > 0) cout << " Point Mass Object: " << pmWt << " lbs. at "
<< "X, Y, Z (in.): " << pmX << " " << pmY << " " << pmZ << "X, Y, Z (in.): " << pmX << " " << pmY << " " << pmZ
<< endl; << endl;
@ -303,3 +320,102 @@ void FGAircraft::Debug(int from)
} }
} }
void FGAircraft::bind(void){
PropertyManager->Tie("metrics/Sw-sqft", this,
&FGAircraft::GetWingArea);
PropertyManager->Tie("metrics/bw-ft", this,
&FGAircraft::GetWingSpan);
PropertyManager->Tie("metrics/cbarw-ft", this,
&FGAircraft::Getcbar);
PropertyManager->Tie("metrics/iw-deg", this,
&FGAircraft::GetWingIncidence);
PropertyManager->Tie("metrics/Sh-sqft", this,
&FGAircraft::GetHTailArea);
PropertyManager->Tie("metrics/lh-ft", this,
&FGAircraft::GetHTailArm);
PropertyManager->Tie("metrics/Sv-sqft", this,
&FGAircraft::GetVTailArea);
PropertyManager->Tie("metrics/lv-ft", this,
&FGAircraft::GetVTailArm);
PropertyManager->Tie("metrics/lh-norm", this,
&FGAircraft::Getlbarh);
PropertyManager->Tie("metrics/lv-norm", this,
&FGAircraft::Getlbarv);
PropertyManager->Tie("metrics/vbarh-norm", this,
&FGAircraft::Getvbarh);
PropertyManager->Tie("metrics/vbarv-norm", this,
&FGAircraft::Getvbarv);
PropertyManager->Tie("moments/l-total-lbsft", this,1,
&FGAircraft::GetMoments);
PropertyManager->Tie("moments/m-total-lbsft", this,2,
&FGAircraft::GetMoments);
PropertyManager->Tie("moments/n-total-lbsft", this,3,
&FGAircraft::GetMoments);
PropertyManager->Tie("forces/fbx-total-lbs", this,1,
&FGAircraft::GetForces);
PropertyManager->Tie("forces/fby-total-lbs", this,2,
&FGAircraft::GetForces);
PropertyManager->Tie("forces/fbz-total-lbs", this,3,
&FGAircraft::GetForces);
PropertyManager->Tie("metrics/aero-rp-x-ft", this,1,
&FGAircraft::GetXYZrp);
PropertyManager->Tie("metrics/aero-rp-y-ft", this,2,
&FGAircraft::GetXYZrp);
PropertyManager->Tie("metrics/aero-rp-z-ft", this,3,
&FGAircraft::GetXYZrp);
PropertyManager->Tie("metrics/eyepoint-x-ft", this,1,
&FGAircraft::GetXYZep);
PropertyManager->Tie("metrics/eyepoint-y-ft", this,2,
&FGAircraft::GetXYZep);
PropertyManager->Tie("metrics/eyepoint-z-ft", this,3,
&FGAircraft::GetXYZep);
PropertyManager->Tie("metrics/alpha-max-deg", this,
&FGAircraft::GetAlphaCLMax,
&FGAircraft::SetAlphaCLMax,
true);
PropertyManager->Tie("metrics/alpha-min-deg", this,
&FGAircraft::GetAlphaCLMin,
&FGAircraft::SetAlphaCLMin,
true);
PropertyManager->Tie("aero/bi2vel", this,
&FGAircraft::GetBI2Vel);
PropertyManager->Tie("aero/ci2vel", this,
&FGAircraft::GetCI2Vel);
PropertyManager->Tie("aero/alpha-wing-rad", this,
&FGAircraft::GetAlphaW);
PropertyManager->Tie("systems/stall-warn-norm", this,
&FGAircraft::GetStallWarn);
}
void FGAircraft::unbind(void){
PropertyManager->Untie("metrics/Sw-sqft");
PropertyManager->Untie("metrics/bw-ft");
PropertyManager->Untie("metrics/cbarw-ft");
PropertyManager->Untie("metrics/iw-deg");
PropertyManager->Untie("metrics/Sh-sqft");
PropertyManager->Untie("metrics/lh-ft");
PropertyManager->Untie("metrics/Sv-sqft");
PropertyManager->Untie("metrics/lv-ft");
PropertyManager->Untie("metrics/lh-norm");
PropertyManager->Untie("metrics/lv-norm");
PropertyManager->Untie("metrics/vbarh-norm");
PropertyManager->Untie("metrics/vbarv-norm");
PropertyManager->Untie("moments/l-total-lbsft");
PropertyManager->Untie("moments/m-total-lbsft");
PropertyManager->Untie("moments/n-total-lbsft");
PropertyManager->Untie("forces/fbx-total-lbs");
PropertyManager->Untie("forces/fby-total-lbs");
PropertyManager->Untie("forces/fbz-total-lbs");
PropertyManager->Untie("metrics/aero-rp-x-ft");
PropertyManager->Untie("metrics/aero-rp-y-ft");
PropertyManager->Untie("metrics/aero-rp-z-ft");
PropertyManager->Untie("metrics/eyepoint-x-ft");
PropertyManager->Untie("metrics/eyepoint-y-ft");
PropertyManager->Untie("metrics/eyepoint-z-ft");
PropertyManager->Untie("metrics/alpha-max-deg");
PropertyManager->Untie("metrics/alpha-min-deg");
PropertyManager->Untie("aero/bi2vel");
PropertyManager->Untie("aero/ci2vel");
PropertyManager->Untie("aero/alpha-wing-rad");
PropertyManager->Untie("systems/stall-warn-norm");
}

47
src/FDM/JSBSim/FGAircraft.h
View file

@ -130,43 +130,51 @@ public:
inline string GetAircraftName(void) { return AircraftName; } inline string GetAircraftName(void) { return AircraftName; }
/// Gets the wing area /// Gets the wing area
inline double GetWingArea(void) { return WingArea; } double GetWingArea(void) const { return WingArea; }
/// Gets the wing span /// Gets the wing span
inline double GetWingSpan(void) { return WingSpan; } double GetWingSpan(void) const { return WingSpan; }
/// Gets the average wing chord /// Gets the average wing chord
inline double Getcbar(void) { return cbar; } double Getcbar(void) const { return cbar; }
inline double GetWingIncidence(void) { return WingIncidence; } inline double GetWingIncidence(void) const { return WingIncidence; }
inline double GetHTailArea(void) { return HTailArea; } inline double GetHTailArea(void) const { return HTailArea; }
inline double GetHTailArm(void) { return HTailArm; } inline double GetHTailArm(void) const { return HTailArm; }
inline double GetVTailArea(void) { return VTailArea; } inline double GetVTailArea(void) const { return VTailArea; }
inline double GetVTailArm(void) { return VTailArm; } inline double GetVTailArm(void) const { return VTailArm; }
inline double Getlbarh(void) { return lbarh; } // HTailArm / cbar inline double Getlbarh(void) const { return lbarh; } // HTailArm / cbar
inline double Getlbarv(void) { return lbarv; } // VTailArm / cbar inline double Getlbarv(void) const { return lbarv; } // VTailArm / cbar
inline double Getvbarh(void) { return vbarh; } // H. Tail Volume inline double Getvbarh(void) const { return vbarh; } // H. Tail Volume
inline double Getvbarv(void) { return vbarv; } // V. Tail Volume inline double Getvbarv(void) const { return vbarv; } // V. Tail Volume
inline FGColumnVector3& GetMoments(void) { return vMoments; } inline FGColumnVector3& GetMoments(void) { return vMoments; }
inline double GetMoments(int idx) { return vMoments(idx); } inline double GetMoments(int idx) const { return vMoments(idx); }
inline FGColumnVector3& GetForces(void) { return vForces; } inline FGColumnVector3& GetForces(void) { return vForces; }
inline double GetForces(int idx) { return vForces(idx); } inline double GetForces(int idx) const { return vForces(idx); }
inline FGColumnVector3& GetBodyAccel(void) { return vBodyAccel; } inline FGColumnVector3& GetBodyAccel(void) { return vBodyAccel; }
inline FGColumnVector3& GetNcg (void) { return vNcg; } inline FGColumnVector3& GetNcg (void) { return vNcg; }
inline FGColumnVector3& GetXYZrp(void) { return vXYZrp; } inline FGColumnVector3& GetXYZrp(void) { return vXYZrp; }
inline FGColumnVector3& GetXYZep(void) { return vXYZep; } inline FGColumnVector3& GetXYZep(void) { return vXYZep; }
inline double GetXYZrp(int idx) { return vXYZrp(idx); } inline double GetXYZrp(int idx) const { return vXYZrp(idx); }
inline double GetXYZep(int idx) { return vXYZep(idx); } inline double GetXYZep(int idx) const { return vXYZep(idx); }
inline double GetAlphaCLMax(void) { return alphaclmax; } inline double GetAlphaCLMax(void) const { return alphaclmax; }
inline double GetAlphaCLMin(void) { return alphaclmin; } inline double GetAlphaCLMin(void) const { return alphaclmin; }
inline void SetAlphaCLMax(double tt) { alphaclmax=tt; } inline void SetAlphaCLMax(double tt) { alphaclmax=tt; }
inline void SetAlphaCLMin(double tt) { alphaclmin=tt; } inline void SetAlphaCLMin(double tt) { alphaclmin=tt; }
inline void SetAircraftName(string name) {AircraftName = name;} inline void SetAircraftName(string name) {AircraftName = name;}
inline double GetStallWarn(void) { return impending_stall; } inline double GetStallWarn(void) const { return impending_stall; }
double GetBI2Vel(void) const { return bi2vel; }
double GetCI2Vel(void) const { return ci2vel; }
double GetAlphaW(void) const { return alphaw; }
float GetNlf(void); float GetNlf(void);
inline FGColumnVector3& GetNwcg(void) { return vNwcg; } inline FGColumnVector3& GetNwcg(void) { return vNwcg; }
void bind(void);
void unbind(void);
private: private:
FGColumnVector3 vMoments; FGColumnVector3 vMoments;
FGColumnVector3 vForces; FGColumnVector3 vForces;
@ -183,6 +191,7 @@ private:
double lbarh,lbarv,vbarh,vbarv; double lbarh,lbarv,vbarh,vbarv;
double alphaclmax,alphaclmin; double alphaclmax,alphaclmin;
double impending_stall; double impending_stall;
double bi2vel, ci2vel,alphaw;
string AircraftName; string AircraftName;
void Debug(int from); void Debug(int from);

56
src/FDM/JSBSim/FGAtmosphere.cpp
View file

@ -59,6 +59,7 @@ INCLUDES
#include "FGMatrix33.h" #include "FGMatrix33.h"
#include "FGColumnVector3.h" #include "FGColumnVector3.h"
#include "FGColumnVector4.h" #include "FGColumnVector4.h"
#include "FGPropertyManager.h"
static const char *IdSrc = "$Id$"; static const char *IdSrc = "$Id$";
static const char *IdHdr = ID_ATMOSPHERE; static const char *IdHdr = ID_ATMOSPHERE;
@ -87,6 +88,7 @@ FGAtmosphere::FGAtmosphere(FGFDMExec* fdmex) : FGModel(fdmex)
// turbType = ttBerndt; // temporarily disable turbulence until fully tested // turbType = ttBerndt; // temporarily disable turbulence until fully tested
TurbGain = 100.0; TurbGain = 100.0;
bind();
Debug(0); Debug(0);
} }
@ -94,6 +96,7 @@ FGAtmosphere::FGAtmosphere(FGFDMExec* fdmex) : FGModel(fdmex)
FGAtmosphere::~FGAtmosphere() FGAtmosphere::~FGAtmosphere()
{ {
unbind();
Debug(1); Debug(1);
} }
@ -346,3 +349,56 @@ void FGAtmosphere::Debug(int from)
} }
} }
void FGAtmosphere::bind(void){
PropertyManager->Tie("atmosphere/T-R", this,
&FGAtmosphere::GetTemperature);
PropertyManager->Tie("atmosphere/rho-slugs_ft3", this,
&FGAtmosphere::GetDensity);
PropertyManager->Tie("atmosphere/P-psf", this,
&FGAtmosphere::GetPressure);
PropertyManager->Tie("atmosphere/a-fps", this,
&FGAtmosphere::GetSoundSpeed);
PropertyManager->Tie("atmosphere/T-sl-R", this,
&FGAtmosphere::GetTemperatureSL);
PropertyManager->Tie("atmosphere/rho-sl-slugs_ft3", this,
&FGAtmosphere::GetDensitySL);
PropertyManager->Tie("atmosphere/P-sl-psf", this,
&FGAtmosphere::GetPressureSL);
PropertyManager->Tie("atmosphere/a-sl-fps", this,
&FGAtmosphere::GetSoundSpeedSL);
PropertyManager->Tie("atmosphere/theta-norm", this,
&FGAtmosphere::GetTemperatureRatio);
PropertyManager->Tie("atmosphere/sigma-norm", this,
&FGAtmosphere::GetDensityRatio);
PropertyManager->Tie("atmosphere/delta-norm", this,
&FGAtmosphere::GetPressureRatio);
PropertyManager->Tie("atmosphere/a-norm", this,
&FGAtmosphere::GetSoundSpeedRatio);
PropertyManager->Tie("atmosphere/psiw-rad", this,
&FGAtmosphere::GetWindPsi);
PropertyManager->Tie("atmosphere/p-turb-rad_sec", this,1,
&FGAtmosphere::GetTurbPQR);
PropertyManager->Tie("atmosphere/q-turb-rad_sec", this,2,
&FGAtmosphere::GetTurbPQR);
PropertyManager->Tie("atmosphere/r-turb-rad_sec", this,3,
&FGAtmosphere::GetTurbPQR);
}
void FGAtmosphere::unbind(void){
PropertyManager->Untie("atmosphere/T-R");
PropertyManager->Untie("atmosphere/rho-slugs_ft3");
PropertyManager->Untie("atmosphere/P-psf");
PropertyManager->Untie("atmosphere/a-fps");
PropertyManager->Untie("atmosphere/T-sl-R");
PropertyManager->Untie("atmosphere/rho-sl-slugs_ft3");
PropertyManager->Untie("atmosphere/P-sl-psf");
PropertyManager->Untie("atmosphere/a-sl-fps");
PropertyManager->Untie("atmosphere/theta-norm");
PropertyManager->Untie("atmosphere/sigma-norm");
PropertyManager->Untie("atmosphere/delta-norm");
PropertyManager->Untie("atmosphere/a-norm");
PropertyManager->Untie("atmosphere/psiw-rad");
PropertyManager->Untie("atmosphere/p-turb-rad_sec");
PropertyManager->Untie("atmosphere/q-turb-rad_sec");
PropertyManager->Untie("atmosphere/r-turb-rad_sec");
}

32
src/FDM/JSBSim/FGAtmosphere.h
View file

@ -91,32 +91,32 @@ public:
bool InitModel(void); bool InitModel(void);
/// Returns the temperature in degrees Rankine. /// Returns the temperature in degrees Rankine.
inline double GetTemperature(void) {return temperature;} inline double GetTemperature(void) const {return temperature;}
/** Returns the density in slugs/ft^3. /** Returns the density in slugs/ft^3.
<i>This function may <b>only</b> be used if Run() is called first.</i> */ <i>This function may <b>only</b> be used if Run() is called first.</i> */
inline double GetDensity(void) {return density;} inline double GetDensity(void) const {return density;}
/// Returns the pressure in psf. /// Returns the pressure in psf.
inline double GetPressure(void) {return pressure;} inline double GetPressure(void) const {return pressure;}
/// Returns the speed of sound in ft/sec. /// Returns the speed of sound in ft/sec.
inline double GetSoundSpeed(void) {return soundspeed;} inline double GetSoundSpeed(void) const {return soundspeed;}
/// Returns the sea level temperature in degrees Rankine. /// Returns the sea level temperature in degrees Rankine.
inline double GetTemperatureSL(void) { return SLtemperature; } inline double GetTemperatureSL(void) const { return SLtemperature; }
/// Returns the sea level density in slugs/ft^3 /// Returns the sea level density in slugs/ft^3
inline double GetDensitySL(void) { return SLdensity; } inline double GetDensitySL(void) const { return SLdensity; }
/// Returns the sea level pressure in psf. /// Returns the sea level pressure in psf.
inline double GetPressureSL(void) { return SLpressure; } inline double GetPressureSL(void) const { return SLpressure; }
/// Returns the sea level speed of sound in ft/sec. /// Returns the sea level speed of sound in ft/sec.
inline double GetSoundSpeedSL(void) { return SLsoundspeed; } inline double GetSoundSpeedSL(void) const { return SLsoundspeed; }
/// Returns the ratio of at-altitude temperature over the sea level value. /// Returns the ratio of at-altitude temperature over the sea level value.
inline double GetTemperatureRatio(void) { return temperature*rSLtemperature; } inline double GetTemperatureRatio(void) const { return temperature*rSLtemperature; }
/// Returns the ratio of at-altitude density over the sea level value. /// Returns the ratio of at-altitude density over the sea level value.
inline double GetDensityRatio(void) { return density*rSLdensity; } inline double GetDensityRatio(void) const { return density*rSLdensity; }
/// Returns the ratio of at-altitude pressure over the sea level value. /// Returns the ratio of at-altitude pressure over the sea level value.
inline double GetPressureRatio(void) { return pressure*rSLpressure; } inline double GetPressureRatio(void) const { return pressure*rSLpressure; }
/// Returns the ratio of at-altitude sound speed over the sea level value. /// Returns the ratio of at-altitude sound speed over the sea level value.
inline double GetSoundSpeedRatio(void) { return soundspeed*rSLsoundspeed; } inline double GetSoundSpeedRatio(void) const { return soundspeed*rSLsoundspeed; }
/// Tells the simulator to use an externally calculated atmosphere model. /// Tells the simulator to use an externally calculated atmosphere model.
inline void UseExternal(void) { useExternal=true; } inline void UseExternal(void) { useExternal=true; }
@ -140,13 +140,17 @@ public:
/** Retrieves the wind direction. The direction is defined as north=0 and /** Retrieves the wind direction. The direction is defined as north=0 and
increases counterclockwise. The wind heading is returned in radians.*/ increases counterclockwise. The wind heading is returned in radians.*/
inline double GetWindPsi(void) { return psiw; } inline double GetWindPsi(void) const { return psiw; }
inline void SetTurbGain(double tt) {TurbGain = tt;} inline void SetTurbGain(double tt) {TurbGain = tt;}
inline double GetTurbPQR(int idx) {return vTurbPQR(idx);} inline double GetTurbPQR(int idx) const {return vTurbPQR(idx);}
inline FGColumnVector3& GetTurbPQR(void) {return vTurbPQR;} inline FGColumnVector3& GetTurbPQR(void) {return vTurbPQR;}
void bind(void);
void unbind(void);
private: private:
double rho; double rho;

66
src/FDM/JSBSim/FGAuxiliary.cpp
View file

@ -54,6 +54,7 @@ INCLUDES
#include "FGMatrix33.h" #include "FGMatrix33.h"
#include "FGColumnVector3.h" #include "FGColumnVector3.h"
#include "FGColumnVector4.h" #include "FGColumnVector4.h"
#include "FGPropertyManager.h"
static const char *IdSrc = "$Id$"; static const char *IdSrc = "$Id$";
static const char *IdHdr = ID_AUXILIARY; static const char *IdHdr = ID_AUXILIARY;
@ -70,6 +71,8 @@ FGAuxiliary::FGAuxiliary(FGFDMExec* fdmex) : FGModel(fdmex)
psl = rhosl = 1; psl = rhosl = 1;
earthPosAngle = 0.0; earthPosAngle = 0.0;
vPilotAccelN.InitMatrix();
Debug(0); Debug(0);
} }
@ -157,6 +160,7 @@ bool FGAuxiliary::Run()
vPilotAccel += Rotation->GetPQRdot() * vToEyePt; vPilotAccel += Rotation->GetPQRdot() * vToEyePt;
vPilotAccel += Rotation->GetPQR() * (Rotation->GetPQR() * vToEyePt); vPilotAccel += Rotation->GetPQR() * (Rotation->GetPQR() * vToEyePt);
//vPilotAccel(2)*=-1; //vPilotAccel(2)*=-1;
vPilotAccelN = vPilotAccel/Inertial->gravity();
} }
earthPosAngle += State->Getdt()*Inertial->omega(); earthPosAngle += State->Getdt()*Inertial->omega();
return false; return false;
@ -193,20 +197,6 @@ double FGAuxiliary::GetCrossWind(void)
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
FGColumnVector3 FGAuxiliary::GetNpilot(void)
{
return vPilotAccel/Inertial->gravity();
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
double FGAuxiliary::GetNpilot(int idx)
{
return (vPilotAccel/Inertial->gravity())(idx);
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
void FGAuxiliary::GetState(void) void FGAuxiliary::GetState(void)
{ {
qbar = Translation->Getqbar(); qbar = Translation->Getqbar();
@ -262,3 +252,51 @@ void FGAuxiliary::Debug(int from)
} }
} }
void FGAuxiliary::bind(void){
PropertyManager->Tie("velocities/vc-fps", this,
&FGAuxiliary::GetVcalibratedFPS);
PropertyManager->Tie("velocities/vc-kts", this,
&FGAuxiliary::GetVcalibratedKTS);
PropertyManager->Tie("velocities/ve-fps", this,
&FGAuxiliary::GetVequivalentFPS);
PropertyManager->Tie("velocities/ve-kts", this,
&FGAuxiliary::GetVequivalentKTS);
PropertyManager->Tie("accelerations/a-pilot-x-ft_sec2", this,1,
&FGAuxiliary::GetPilotAccel);
PropertyManager->Tie("accelerations/a-pilot-y-ft_sec2", this,2,
&FGAuxiliary::GetPilotAccel);
PropertyManager->Tie("accelerations/a-pilot-z-ft_sec2", this,3,
&FGAuxiliary::GetPilotAccel);
PropertyManager->Tie("accelerations/n-pilot-x-norm", this,1,
&FGAuxiliary::GetNpilot);
PropertyManager->Tie("accelerations/n-pilot-y-norm", this,2,
&FGAuxiliary::GetNpilot);
PropertyManager->Tie("accelerations/n-pilot-z-norm", this,3,
&FGAuxiliary::GetNpilot);
PropertyManager->Tie("position/epa-rad", this,
&FGAuxiliary::GetEarthPositionAngle);
/* PropertyManager->Tie("atmosphere/headwind-fps", this,
&FGAuxiliary::GetHeadWind,
true);
PropertyManager->Tie("atmosphere/crosswind-fps", this,
&FGAuxiliary::GetCrossWind,
true); */
}
void FGAuxiliary::unbind(void){
PropertyManager->Untie("velocities/vc-fps");
PropertyManager->Untie("velocities/vc-kts");
PropertyManager->Untie("velocities/ve-fps");
PropertyManager->Untie("velocities/ve-kts");
PropertyManager->Untie("accelerations/a-pilot-x-ft_sec2");
PropertyManager->Untie("accelerations/a-pilot-y-ft_sec2");
PropertyManager->Untie("accelerations/a-pilot-z-ft_sec2");
PropertyManager->Untie("accelerations/n-pilot-x-norm");
PropertyManager->Untie("accelerations/n-pilot-y-norm");
PropertyManager->Untie("accelerations/n-pilot-z-norm");
PropertyManager->Untie("position/epa-rad");
/* PropertyManager->Untie("atmosphere/headwind-fps");
PropertyManager->Untie("atmosphere/crosswind-fps"); */
}

20
src/FDM/JSBSim/FGAuxiliary.h
View file

@ -85,21 +85,24 @@ public:
bool Run(void); bool Run(void);
// Use FGInitialCondition to set these speeds // Use FGInitialCondition to set these speeds
inline double GetVcalibratedFPS(void) { return vcas; } inline double GetVcalibratedFPS(void) const { return vcas; }
inline double GetVcalibratedKTS(void) { return vcas*fpstokts; } inline double GetVcalibratedKTS(void) const { return vcas*fpstokts; }
inline double GetVequivalentFPS(void) { return veas; } inline double GetVequivalentFPS(void) const { return veas; }
inline double GetVequivalentKTS(void) { return veas*fpstokts; } inline double GetVequivalentKTS(void) const { return veas*fpstokts; }
inline FGColumnVector3& GetPilotAccel(void) { return vPilotAccel; } inline FGColumnVector3& GetPilotAccel(void) { return vPilotAccel; }
inline double GetPilotAccel(int idx) { return vPilotAccel(idx); } inline double GetPilotAccel(int idx) const { return vPilotAccel(idx); }
FGColumnVector3 GetNpilot(void); FGColumnVector3 GetNpilot(void) const { return vPilotAccelN; }
double GetNpilot(int idx); double GetNpilot(int idx) const { return vPilotAccelN(idx); }
inline double GetEarthPositionAngle(void) { return earthPosAngle; } inline double GetEarthPositionAngle(void) const { return earthPosAngle; }
double GetHeadWind(void); double GetHeadWind(void);
double GetCrossWind(void); double GetCrossWind(void);
void bind(void);
void unbind(void);
private: private:
double vcas; double vcas;
double veas; double veas;
@ -114,6 +117,7 @@ private:
// isentropic flow equations // isentropic flow equations
FGColumnVector3 vPilotAccel; FGColumnVector3 vPilotAccel;
FGColumnVector3 vPilotAccelN;
FGColumnVector3 vToEyePt; FGColumnVector3 vToEyePt;
double earthPosAngle; double earthPosAngle;

94
src/FDM/JSBSim/FGCoefficient.cpp
View file

@ -47,6 +47,7 @@ INCLUDES
#include "FGCoefficient.h" #include "FGCoefficient.h"
#include "FGState.h" #include "FGState.h"
#include "FGFDMExec.h" #include "FGFDMExec.h"
#include "FGPropertyManager.h"
#ifndef FGFS #ifndef FGFS
# if defined(sgi) && !defined(__GNUC__) # if defined(sgi) && !defined(__GNUC__)
@ -72,9 +73,15 @@ FGCoefficient::FGCoefficient( FGFDMExec* fdex )
State = FDMExec->GetState(); State = FDMExec->GetState();
Table = 0; Table = 0;
PropertyManager = FDMExec->GetPropertyManager();
bias=0; bias=0;
gain=1; gain=1;
LookupR = LookupC = 0;
totalValue = 0;
if (debug_lvl & 2) cout << "Instantiated: FGCoefficient" << endl; if (debug_lvl & 2) cout << "Instantiated: FGCoefficient" << endl;
} }
@ -91,7 +98,7 @@ FGCoefficient::~FGCoefficient()
bool FGCoefficient::Load(FGConfigFile *AC_cfg) bool FGCoefficient::Load(FGConfigFile *AC_cfg)
{ {
int start, end, n; int start, end, n;
string mult; string mult,prop;
if (AC_cfg) { if (AC_cfg) {
name = AC_cfg->GetValue("NAME"); name = AC_cfg->GetValue("NAME");
@ -115,12 +122,15 @@ bool FGCoefficient::Load(FGConfigFile *AC_cfg)
} }
*AC_cfg >> multparmsRow; *AC_cfg >> multparmsRow;
LookupR = State->GetParameterIndex(multparmsRow); prop = State->GetPropertyName( State->GetParameterIndex(multparmsRow) );
LookupR = PropertyManager->GetNode( prop );
} }
if (type == TABLE) { if (type == TABLE) {
*AC_cfg >> multparmsCol; *AC_cfg >> multparmsCol;
LookupC = State->GetParameterIndex(multparmsCol); prop = State->GetPropertyName( State->GetParameterIndex(multparmsCol) );
LookupC = PropertyManager->GetNode( prop );
} }
// Here, read in the line of the form (e.g.) FG_MACH|FG_QBAR|FG_ALPHA // Here, read in the line of the form (e.g.) FG_MACH|FG_QBAR|FG_ALPHA
@ -137,11 +147,15 @@ bool FGCoefficient::Load(FGConfigFile *AC_cfg)
while (n < end && n >= 0) { while (n < end && n >= 0) {
n -= start; n -= start;
mult = multparms.substr(start,n); mult = multparms.substr(start,n);
multipliers.push_back( State->GetParameterIndex(mult) ); prop= State->GetPropertyName( State->GetParameterIndex(mult) );
multipliers.push_back( PropertyManager->GetNode(prop) );
start += n+1; start += n+1;
n = multparms.find("|",start); n = multparms.find("|",start);
} }
multipliers.push_back(State->GetParameterIndex(multparms.substr(start,n))); prop=State->GetPropertyName(
State->GetParameterIndex( multparms.substr(start,n) ) );
mult = multparms.substr(start,n);
multipliers.push_back( PropertyManager->GetNode(prop) );
// End of non-dimensionalizing parameter read-in // End of non-dimensionalizing parameter read-in
} }
@ -175,7 +189,7 @@ double FGCoefficient::Value(double rVal, double cVal)
for (midx=0; midx < multipliers.size(); midx++) { for (midx=0; midx < multipliers.size(); midx++) {
Value *= State->GetParameter(multipliers[midx]); Value *= multipliers[midx]->getDoubleValue();
} }
return Value; return Value;
} }
@ -189,7 +203,7 @@ double FGCoefficient::Value(double Val)
SD = Value = gain*Table->GetValue(Val) + bias; SD = Value = gain*Table->GetValue(Val) + bias;
for (unsigned int midx=0; midx < multipliers.size(); midx++) for (unsigned int midx=0; midx < multipliers.size(); midx++)
Value *= State->GetParameter(multipliers[midx]); Value *= multipliers[midx]->getDoubleValue();
return Value; return Value;
} }
@ -203,28 +217,34 @@ double FGCoefficient::Value(void)
SD = Value = gain*StaticValue + bias; SD = Value = gain*StaticValue + bias;
for (unsigned int midx=0; midx < multipliers.size(); midx++) for (unsigned int midx=0; midx < multipliers.size(); midx++)
Value *= State->GetParameter(multipliers[midx]); Value *= multipliers[midx]->getDoubleValue();
return Value; return Value;
} }
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
double FGCoefficient::TotalValue() double FGCoefficient::TotalValue(void)
{ {
switch(type) { switch(type) {
case 0: case 0:
return -1; totalValue=-1;
return totalValue;
case 1: case 1:
return (Value()); totalValue=Value();
return totalValue;
case 2: case 2:
return (Value(State->GetParameter(LookupR))); totalValue=Value( LookupR->getDoubleValue() );
return totalValue;
case 3: case 3:
return (Value(State->GetParameter(LookupR),State->GetParameter(LookupC))); totalValue=Value( LookupR->getDoubleValue(),
LookupC->getDoubleValue() );
return totalValue;
case 4: case 4:
return 0.0; totalValue=0.0;
return totalValue;
} }
return 0; return totalValue;
} }
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@ -246,7 +266,7 @@ void FGCoefficient::DisplayCoeffFactors(void)
cout << "none" << endl; cout << "none" << endl;
} else { } else {
for (i=0; i<multipliers.size(); i++) for (i=0; i<multipliers.size(); i++)
cout << State->GetParameterName(multipliers[i]); cout << multipliers[i]->getName() << " ";
} }
cout << endl; cout << endl;
} }
@ -263,6 +283,44 @@ string FGCoefficient::GetCoefficientValues(void)
return value; return value;
} }
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
void FGCoefficient::bind(FGPropertyManager *node) {
string mult;
unsigned i;
FGCoefficient::node=node;
node->SetString("description",description);
if(LookupR) node->SetString("row-parm",LookupR->getName() );
if(LookupC) node->SetString("column-parm",LookupC->getName() );
mult="";
for (i=0; i<multipliers.size(); i++) {
mult += multipliers[i]->getName();
if( i < multipliers.size()-1 ) mult += "|";
}
node->SetString("multipliers",mult);
node->Tie("SD-norm",this,&FGCoefficient::GetSD );
node->Tie("value-lbs",this,&FGCoefficient::GetValue );
node->Tie("bias", this, &FGCoefficient::getBias,
&FGCoefficient::setBias );
node->Tie("gain", this, &FGCoefficient::getGain,
&FGCoefficient::setGain );
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
void FGCoefficient::unbind(void) {
node->Untie("SD-norm");
node->Untie("value-lbs");
node->Untie("bias");
node->Untie("gain");
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// The bitmasked value choices are as follows: // The bitmasked value choices are as follows:
// unset: In this case (the default) JSBSim would only print // unset: In this case (the default) JSBSim would only print
@ -298,11 +356,11 @@ void FGCoefficient::Debug(int from)
if (type == TABLE) { if (type == TABLE) {
cout << "Cols: " << columns; cout << "Cols: " << columns;
} }
cout << endl << " Row indexing parameter: " << multparmsRow << endl; cout << endl << " Row indexing parameter: " << LookupR->getName() << endl;
} }
if (type == TABLE) { if (type == TABLE) {
cout << " Column indexing parameter: " << multparmsCol << endl; cout << " Column indexing parameter: " << LookupC->getName() << endl;
} }
if (type == VALUE) { if (type == VALUE) {

21
src/FDM/JSBSim/FGCoefficient.h
View file

@ -47,6 +47,7 @@ INCLUDES
#include "FGConfigFile.h" #include "FGConfigFile.h"
#include "FGTable.h" #include "FGTable.h"
#include "FGJSBBase.h" #include "FGJSBBase.h"
#include "FGPropertyManager.h"
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
DEFINITIONS DEFINITIONS
@ -103,10 +104,11 @@ public:
virtual bool Load(FGConfigFile* AC_cfg); virtual bool Load(FGConfigFile* AC_cfg);
typedef vector <eParam> MultVec; typedef vector <FGPropertyManager*> MultVec;
virtual double TotalValue(void); virtual double TotalValue(void);
virtual inline string Getname(void) {return name;} virtual inline double GetValue(void) const { return totalValue; }
virtual inline double GetSD(void) { return SD;} virtual inline string Getname(void) const {return name;}
virtual inline double GetSD(void) const { return SD;}
inline MultVec Getmultipliers(void) {return multipliers;} inline MultVec Getmultipliers(void) {return multipliers;}
void DumpSD(void); void DumpSD(void);
@ -120,8 +122,11 @@ public:
inline void setBias(double b) { bias=b; } inline void setBias(double b) { bias=b; }
inline void setGain(double g) { gain=g; }; inline void setGain(double g) { gain=g; };
inline double getBias(void) { return bias; } inline double getBias(void) const { return bias; }
inline double getGain(void) { return gain; } inline double getGain(void) const { return gain; }
void bind(FGPropertyManager *node);
void unbind(void);
private: private:
enum Type {UNKNOWN, VALUE, VECTOR, TABLE, EQUATION}; enum Type {UNKNOWN, VALUE, VECTOR, TABLE, EQUATION};
@ -138,8 +143,11 @@ private:
double Value(double); double Value(double);
double Value(void); double Value(void);
double StaticValue; double StaticValue;
double totalValue;
double bias,gain; double bias,gain;
eParam LookupR, LookupC; FGPropertyManager *LookupR, *LookupC;
FGPropertyManager *node;
MultVec multipliers; MultVec multipliers;
int rows, columns; int rows, columns;
Type type; Type type;
@ -156,6 +164,7 @@ private:
FGPosition* Position; FGPosition* Position;
FGAuxiliary* Auxiliary; FGAuxiliary* Auxiliary;
FGOutput* Output; FGOutput* Output;
FGPropertyManager* PropertyManager;
virtual void Debug(int from); virtual void Debug(int from);
}; };

249
src/FDM/JSBSim/FGFCS.cpp
View file

@ -47,6 +47,7 @@ INCLUDES
#include "FGPosition.h" #include "FGPosition.h"
#include "FGAuxiliary.h" #include "FGAuxiliary.h"
#include "FGOutput.h" #include "FGOutput.h"
#include "FGPropertyManager.h"
#include "filtersjb/FGFilter.h" #include "filtersjb/FGFilter.h"
#include "filtersjb/FGDeadBand.h" #include "filtersjb/FGDeadBand.h"
@ -70,12 +71,17 @@ FGFCS::FGFCS(FGFDMExec* fdmex) : FGModel(fdmex)
DaCmd = DeCmd = DrCmd = DfCmd = DsbCmd = DspCmd = 0.0; DaCmd = DeCmd = DrCmd = DfCmd = DsbCmd = DspCmd = 0.0;
PTrimCmd = YTrimCmd = RTrimCmd = 0.0; PTrimCmd = YTrimCmd = RTrimCmd = 0.0;
DaLPos = DaRPos = DePos = DrPos = DfPos = DsbPos = DspPos = 0.0;
GearCmd = GearPos = 1; // default to gear down GearCmd = GearPos = 1; // default to gear down
LeftBrake = RightBrake = CenterBrake = 0.0; LeftBrake = RightBrake = CenterBrake = 0.0;
DoNormalize=true; DoNormalize=true;
for(i=0;i<6;i++) { ToNormalize[i]=-1;} bind();
for(i=0;i<=NForms;i++) {
DePos[i] = DaLPos[i] = DaRPos[i] = DrPos[i] = 0.0;
DfPos[i] = DsbPos[i] = DspPos[i] = 0.0;
}
for(i=0;i<NNorm;i++) { ToNormalize[i]=-1;}
Debug(0); Debug(0);
} }
@ -92,6 +98,8 @@ FGFCS::~FGFCS()
unsigned int i; unsigned int i;
unbind();
for (i=0;i<Components.size();i++) delete Components[i]; for (i=0;i<Components.size();i++) delete Components[i];
Debug(1); Debug(1);
} }
@ -304,20 +312,20 @@ bool FGFCS::Load(FGConfigFile* AC_cfg)
if(Components[i]->GetType() == "AEROSURFACE_SCALE" if(Components[i]->GetType() == "AEROSURFACE_SCALE"
|| Components[i]->GetType() == "KINEMAT" ) { || Components[i]->GetType() == "KINEMAT" ) {
if( Components[i]->GetOutputIdx() == FG_ELEVATOR_POS ) { if( Components[i]->GetOutputIdx() == FG_ELEVATOR_POS ) {
ToNormalize[iNDe]=i; ToNormalize[iDe]=i;
} else if ( Components[i]->GetOutputIdx() == FG_LEFT_AILERON_POS } else if ( Components[i]->GetOutputIdx() == FG_LEFT_AILERON_POS
|| Components[i]->GetOutputIdx() == FG_AILERON_POS ) { || Components[i]->GetOutputIdx() == FG_AILERON_POS ) {
ToNormalize[iNDaL]=i; ToNormalize[iDaL]=i;
} else if ( Components[i]->GetOutputIdx() == FG_RIGHT_AILERON_POS ) { } else if ( Components[i]->GetOutputIdx() == FG_RIGHT_AILERON_POS ) {
ToNormalize[iNDaR]=i; ToNormalize[iDaR]=i;
} else if ( Components[i]->GetOutputIdx() == FG_RUDDER_POS ) { } else if ( Components[i]->GetOutputIdx() == FG_RUDDER_POS ) {
ToNormalize[iNDr]=i; ToNormalize[iDr]=i;
} else if ( Components[i]->GetOutputIdx() == FG_SPDBRAKE_POS ) { } else if ( Components[i]->GetOutputIdx() == FG_SPDBRAKE_POS ) {
ToNormalize[iNDsb]=i; ToNormalize[iDsb]=i;
} else if ( Components[i]->GetOutputIdx() == FG_SPOILERS_POS ) { } else if ( Components[i]->GetOutputIdx() == FG_SPOILERS_POS ) {
ToNormalize[iNDsp]=i; ToNormalize[iDsp]=i;
} else if ( Components[i]->GetOutputIdx() == FG_FLAPS_POS ) { } else if ( Components[i]->GetOutputIdx() == FG_FLAPS_POS ) {
ToNormalize[iNDf]=i; ToNormalize[iDf]=i;
} }
} }
} }
@ -407,29 +415,224 @@ void FGFCS::AddThrottle(void)
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
void FGFCS::Normalize(void) { void FGFCS::Normalize(void) {
if( ToNormalize[iNDe] > -1 )
DePosN = Components[ToNormalize[iNDe]]->GetOutputPct();
if( ToNormalize[iNDaL] > -1 ) //not all of these are guaranteed to be defined for every model
DaLPosN = Components[ToNormalize[iNDaL]]->GetOutputPct(); //those that are have an index >=0 in the ToNormalize array
//ToNormalize is filled in Load()
if( ToNormalize[iNDaR] > -1 ) if( ToNormalize[iDe] > -1 ) {
DaRPosN = Components[ToNormalize[iNDaR]]->GetOutputPct(); DePos[ofNorm] = Components[ToNormalize[iDe]]->GetOutputPct();
}
if( ToNormalize[iNDr] > -1 ) if( ToNormalize[iDaL] > -1 ) {
DrPosN = Components[ToNormalize[iNDr]]->GetOutputPct(); DaLPos[ofNorm] = Components[ToNormalize[iDaL]]->GetOutputPct();
}
if( ToNormalize[iNDsb] > -1 ) if( ToNormalize[iDaR] > -1 ) {
DsbPosN = Components[ToNormalize[iNDsb]]->GetOutputPct(); DaRPos[ofNorm] = Components[ToNormalize[iDaR]]->GetOutputPct();
}
if( ToNormalize[iNDsp] > -1 ) if( ToNormalize[iDr] > -1 ) {
DspPosN = Components[ToNormalize[iNDsp]]->GetOutputPct(); DrPos[ofNorm] = Components[ToNormalize[iDr]]->GetOutputPct();
}
if( ToNormalize[iNDf] > -1 ) if( ToNormalize[iDsb] > -1 ) {
DfPosN = Components[ToNormalize[iNDf]]->GetOutputPct(); DsbPos[ofNorm] = Components[ToNormalize[iDsb]]->GetOutputPct();
}
if( ToNormalize[iDsp] > -1 ) {
DspPos[ofNorm] = Components[ToNormalize[iDsp]]->GetOutputPct();
}
if( ToNormalize[iDf] > -1 ) {
DfPos[ofNorm] = Components[ToNormalize[iDf]]->GetOutputPct();
}
DePos[ofMag] = fabs(DePos[ofRad]);
DaLPos[ofMag] = fabs(DaLPos[ofRad]);
DaRPos[ofMag] = fabs(DaRPos[ofRad]);
DrPos[ofMag] = fabs(DrPos[ofRad]);
DsbPos[ofMag] = fabs(DsbPos[ofRad]);
DspPos[ofMag] = fabs(DspPos[ofRad]);
DfPos[ofMag] = fabs(DfPos[ofRad]);
} }
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
void FGFCS::bind(void){
PropertyManager->Tie("fcs/aileron-cmd-norm", this,
&FGFCS::GetDaCmd,
&FGFCS::SetDaCmd,
true);
PropertyManager->Tie("fcs/elevator-cmd-norm", this,
&FGFCS::GetDeCmd,
&FGFCS::SetDeCmd,
true);
PropertyManager->Tie("fcs/rudder-cmd-norm", this,
&FGFCS::GetDrCmd,
&FGFCS::SetDrCmd,
true);
PropertyManager->Tie("fcs/flap-cmd-norm", this,
&FGFCS::GetDfCmd,
&FGFCS::SetDfCmd,
true);
PropertyManager->Tie("fcs/speedbrake-cmd-norm", this,
&FGFCS::GetDsbCmd,
&FGFCS::SetDsbCmd,
true);
PropertyManager->Tie("fcs/spoiler-cmd-norm", this,
&FGFCS::GetDspCmd,
&FGFCS::SetDspCmd,
true);
PropertyManager->Tie("fcs/pitch-trim-cmd-norm", this,
&FGFCS::GetPitchTrimCmd,
&FGFCS::SetPitchTrimCmd,
true);
PropertyManager->Tie("fcs/roll-trim-cmd-norm", this,
&FGFCS::GetYawTrimCmd,
&FGFCS::SetYawTrimCmd,
true);
PropertyManager->Tie("fcs/yaw-trim-cmd-norm", this,
&FGFCS::GetRollTrimCmd,
&FGFCS::SetRollTrimCmd,
true);
PropertyManager->Tie("gear/gear-cmd-norm", this,
&FGFCS::GetGearCmd,
&FGFCS::SetGearCmd,
true);
PropertyManager->Tie("fcs/left-aileron-pos-rad", this,ofRad,
&FGFCS::GetDaLPos,
&FGFCS::SetDaLPos,
true);
PropertyManager->Tie("fcs/left-aileron-pos-norm", this,ofNorm,
&FGFCS::GetDaLPos,
&FGFCS::SetDaLPos,
true);
PropertyManager->Tie("fcs/mag-left-aileron-pos-rad", this,ofMag,
&FGFCS::GetDaLPos,
&FGFCS::SetDaLPos,
true);
PropertyManager->Tie("fcs/right-aileron-pos-rad", this,ofRad,
&FGFCS::GetDaRPos,
&FGFCS::SetDaRPos,
true);
PropertyManager->Tie("fcs/right-aileron-pos-norm", this,ofNorm,
&FGFCS::GetDaRPos,
&FGFCS::SetDaRPos,
true);
PropertyManager->Tie("fcs/mag-right-aileron-pos-rad", this,ofMag,
&FGFCS::GetDaRPos,
&FGFCS::SetDaRPos,
true);
PropertyManager->Tie("fcs/elevator-pos-rad", this, ofRad,
&FGFCS::GetDePos,
&FGFCS::SetDePos,
true );
PropertyManager->Tie("fcs/elevator-pos-norm", this,ofNorm,
&FGFCS::GetDePos,
&FGFCS::SetDePos,
true );
PropertyManager->Tie("fcs/mag-elevator-pos-rad", this,ofMag,
&FGFCS::GetDePos,
&FGFCS::SetDePos,
true );
PropertyManager->Tie("fcs/rudder-pos-rad", this,ofRad,
&FGFCS::GetDrPos,
&FGFCS::SetDrPos,
true);
PropertyManager->Tie("fcs/rudder-pos-norm", this,ofNorm,
&FGFCS::GetDrPos,
&FGFCS::SetDrPos,
true);
PropertyManager->Tie("fcs/mag-rudder-pos-rad", this,ofMag,
&FGFCS::GetDrPos,
&FGFCS::SetDrPos,
true);
PropertyManager->Tie("fcs/flap-pos-deg", this,ofRad,
&FGFCS::GetDfPos,
&FGFCS::SetDfPos,
true);
PropertyManager->Tie("fcs/flap-pos-norm", this,ofNorm,
&FGFCS::GetDfPos,
&FGFCS::SetDfPos,
true);
PropertyManager->Tie("fcs/speedbrake-pos-rad", this,ofRad,
&FGFCS::GetDsbPos,
&FGFCS::SetDsbPos,
true);
PropertyManager->Tie("fcs/speedbrake-pos-norm", this,ofNorm,
&FGFCS::GetDsbPos,
&FGFCS::SetDsbPos,
true);
PropertyManager->Tie("fcs/mag-speedbrake-pos-rad", this,ofMag,
&FGFCS::GetDsbPos,
&FGFCS::SetDsbPos,
true);
PropertyManager->Tie("fcs/spoiler-pos-rad", this,ofRad,
&FGFCS::GetDspPos,
&FGFCS::SetDspPos,
true);
PropertyManager->Tie("fcs/spoiler-pos-norm", this,ofNorm,
&FGFCS::GetDspPos,
&FGFCS::SetDspPos,
true);
PropertyManager->Tie("fcs/mag-spoiler-pos-rad", this,ofMag,
&FGFCS::GetDspPos,
&FGFCS::SetDspPos,
true);
PropertyManager->Tie("gear/gear-pos-norm", this,
&FGFCS::GetGearPos,
&FGFCS::SetGearPos,
true);
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
void FGFCS::unbind(void){
PropertyManager->Untie("fcs/aileron-cmd-norm");
PropertyManager->Untie("fcs/elevator-cmd-norm");
PropertyManager->Untie("fcs/rudder-cmd-norm");
PropertyManager->Untie("fcs/flap-cmd-norm");
PropertyManager->Untie("fcs/speedbrake-cmd-norm");
PropertyManager->Untie("fcs/spoiler-cmd-norm");
PropertyManager->Untie("fcs/pitch-trim-cmd-norm");
PropertyManager->Untie("fcs/roll-trim-cmd-norm");
PropertyManager->Untie("fcs/yaw-trim-cmd-norm");
PropertyManager->Untie("gear/gear-cmd-norm");
PropertyManager->Untie("fcs/left-aileron-pos-rad");
PropertyManager->Untie("fcs/mag-left-aileron-pos-rad");
PropertyManager->Untie("fcs/left-aileron-pos-norm");
PropertyManager->Untie("fcs/right-aileron-pos-rad");
PropertyManager->Untie("fcs/mag-right-aileron-pos-rad");
PropertyManager->Untie("fcs/right-aileron-pos-norm");
PropertyManager->Untie("fcs/elevator-pos-rad");
PropertyManager->Untie("fcs/mag-elevator-pos-rad");
PropertyManager->Untie("fcs/elevator-pos-norm");
PropertyManager->Untie("fcs/rudder-pos-rad");
PropertyManager->Untie("fcs/mag-rudder-pos-rad");
PropertyManager->Untie("fcs/rudder-pos-norm");
PropertyManager->Untie("fcs/flap-pos-deg");
PropertyManager->Untie("fcs/flap-pos-norm");
PropertyManager->Untie("fcs/speedbrake-pos-rad");
PropertyManager->Untie("fcs/mag-speedbrake-pos-rad");
PropertyManager->Untie("fcs/speedbrake-pos-norm");
PropertyManager->Untie("fcs/spoiler-pos-rad");
PropertyManager->Untie("fcs/mag-spoiler-pos-rad");
PropertyManager->Untie("fcs/spoiler-pos-norm");
PropertyManager->Untie("gear/gear-pos-norm");
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// The bitmasked value choices are as follows: // The bitmasked value choices are as follows:
// unset: In this case (the default) JSBSim would only print // unset: In this case (the default) JSBSim would only print

156
src/FDM/JSBSim/FGFCS.h
View file

@ -153,7 +153,10 @@ CLASS DOCUMENTATION
CLASS DECLARATION CLASS DECLARATION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
typedef enum { iNDe=0, iNDaL, iNDaR, iNDr, iNDsb, iNDsp, iNDf } NormalizeIdx; typedef enum { iDe=0, iDaL, iDaR, iDr, iDsb, iDsp, iDf } FcIdx;
int const NNorm=7;
typedef enum { ofRad=0, ofNorm, ofMag } OutputForm;
int const NForms=3;
class FGFCS : public FGModel { class FGFCS : public FGModel {
@ -172,27 +175,27 @@ public:
//@{ //@{
/** Gets the aileron command. /** Gets the aileron command.
@return aileron command in percent */ @return aileron command in percent */
inline double GetDaCmd(void) { return DaCmd; } inline double GetDaCmd(void) const { return DaCmd; }
/** Gets the elevator command. /** Gets the elevator command.
@return elevator command in percent */ @return elevator command in percent */
inline double GetDeCmd(void) { return DeCmd; } inline double GetDeCmd(void) const { return DeCmd; }
/** Gets the rudder command. /** Gets the rudder command.
@return rudder command in percent */ @return rudder command in percent */
inline double GetDrCmd(void) { return DrCmd; } inline double GetDrCmd(void) const { return DrCmd; }
/** Gets the flaps command. /** Gets the flaps command.
@return flaps command in percent */ @return flaps command in percent */
inline double GetDfCmd(void) { return DfCmd; } inline double GetDfCmd(void) const { return DfCmd; }
/** Gets the speedbrake command. /** Gets the speedbrake command.
@return speedbrake command in percent */ @return speedbrake command in percent */
inline double GetDsbCmd(void) { return DsbCmd; } inline double GetDsbCmd(void) const { return DsbCmd; }
/** Gets the spoiler command. /** Gets the spoiler command.
@return spoiler command in percent */ @return spoiler command in percent */
inline double GetDspCmd(void) { return DspCmd; } inline double GetDspCmd(void) const { return DspCmd; }
/** Gets the throttle command. /** Gets the throttle command.
@param engine engine ID number @param engine engine ID number
@ -202,94 +205,70 @@ public:
/** Gets the mixture command. /** Gets the mixture command.
@param engine engine ID number @param engine engine ID number
@return mixture command in percent ( 0 - 100) for the given engine */ @return mixture command in percent ( 0 - 100) for the given engine */
inline double GetMixtureCmd(int engine) { return MixtureCmd[engine]; } inline double GetMixtureCmd(int engine) const { return MixtureCmd[engine]; }
/** Gets the prop pitch command. /** Gets the prop pitch command.
@param engine engine ID number @param engine engine ID number
@return pitch command in percent ( 0.0 - 1.0) for the given engine */ @return pitch command in percent ( 0.0 - 1.0) for the given engine */
inline double GetPropAdvanceCmd(int engine) { return PropAdvanceCmd[engine]; } inline double GetPropAdvanceCmd(int engine) const { return PropAdvanceCmd[engine]; }
/** Gets the pitch trim command. /** Gets the pitch trim command.
@return pitch trim command in percent */ @return pitch trim command in percent */
inline double GetPitchTrimCmd(void) { return PTrimCmd; } inline double GetPitchTrimCmd(void) const { return PTrimCmd; }
/** Gets the rudder trim command. /** Gets the rudder trim command.
@return rudder trim command in percent */ @return rudder trim command in percent */
inline double GetYawTrimCmd(void) { return YTrimCmd; } inline double GetYawTrimCmd(void) const { return YTrimCmd; }
/** Gets the aileron trim command. /** Gets the aileron trim command.
@return aileron trim command in percent */ @return aileron trim command in percent */
inline double GetRollTrimCmd(void) { return RTrimCmd; } inline double GetRollTrimCmd(void) const { return RTrimCmd; }
/** Get the gear extend/retract command. 0 commands gear up, 1 down. /** Get the gear extend/retract command. 0 commands gear up, 1 down.
defaults to down. defaults to down.
@return the current value of the gear extend/retract command*/ @return the current value of the gear extend/retract command*/
inline double GetGearCmd(void) { return GearCmd; } inline double GetGearCmd(void) const { return GearCmd; }
//@} //@}
/// @name Aerosurface position retrieval /// @name Aerosurface position retrieval
//@{ //@{
/** Gets the left aileron position. /** Gets the left aileron position.
@return aileron position in radians */ @return aileron position in radians */
inline double GetDaLPos(void) { return DaLPos; } inline double GetDaLPos( int form = ofRad )
const { return DaLPos[form]; }
/// @name Aerosurface position retrieval
//@{
/** Gets the normalized left aileron position.
@return aileron position in radians */
inline double GetDaLPosN(void) { return DaLPosN; }
/// @name Aerosurface position retrieval /// @name Aerosurface position retrieval
//@{ //@{
/** Gets the right aileron position. /** Gets the right aileron position.
@return aileron position in radians */ @return aileron position in radians */
inline double GetDaRPos(void) { return DaRPos; } inline double GetDaRPos( int form = ofRad )
const { return DaRPos[form]; }
/// @name Aerosurface position retrieval
//@{
/** Gets the normalized right aileron position.
@return right aileron position in percent (-1..1) */
inline double GetDaRPosN(void) { return DaRPosN; }
/** Gets the elevator position. /** Gets the elevator position.
@return elevator position in radians */ @return elevator position in radians */
inline double GetDePos(void) { return DePos; } inline double GetDePos( int form = ofRad )
const { return DePos[form]; }
/** Gets the normalized elevator position.
@return elevator position in percent (-1..1) */
inline double GetDePosN(void) { return DePosN; }
/** Gets the rudder position. /** Gets the rudder position.
@return rudder position in radians */ @return rudder position in radians */
inline double GetDrPos(void) { return DrPos; } inline double GetDrPos( int form = ofRad )
const { return DrPos[form]; }
/** Gets the normalized rudder position.
@return rudder position in percent (-1..1) */
inline double GetDrPosN(void) { return DrPosN; }
/** Gets the flaps position.
@return flaps position in radians */
inline double GetDfPos(void) { return DfPos; }
/** Gets the normalized flaps position.
@return flaps position in percent (-1..1) */
inline double GetDfPosN(void) { return DfPosN; }
/** Gets the speedbrake position. /** Gets the speedbrake position.
@return speedbrake position in radians */ @return speedbrake position in radians */
inline double GetDsbPos(void) { return DsbPos; } inline double GetDsbPos( int form = ofRad )
const { return DsbPos[form]; }
/** Gets the normalized speedbrake position.
@return speedbrake position in percent (-1..1) */
inline double GetDsbPosN(void) { return DsbPosN; }
/** Gets the spoiler position. /** Gets the spoiler position.
@return spoiler position in radians */ @return spoiler position in radians */
inline double GetDspPos(void) { return DspPos; } inline double GetDspPos( int form = ofRad )
const { return DspPos[form]; }
/** Gets the flaps position.
@return flaps position in radians */
inline double GetDfPos( int form = ofRad )
const { return DspPos[form]; }
/** Gets the normalized spoiler position.
@return spoiler position in percent (-1..1) */
inline double GetDspPosN(void) { return DspPosN; }
/** Gets the throttle position. /** Gets the throttle position.
@param engine engine ID number @param engine engine ID number
@ -299,16 +278,16 @@ public:
/** Gets the mixture position. /** Gets the mixture position.
@param engine engine ID number @param engine engine ID number
@return mixture position for the given engine in percent ( 0 - 100)*/ @return mixture position for the given engine in percent ( 0 - 100)*/
inline double GetMixturePos(int engine) { return MixturePos[engine]; } inline double GetMixturePos(int engine) const { return MixturePos[engine]; }
/** Gets the gear position (0 up, 1 down), defaults to down /** Gets the gear position (0 up, 1 down), defaults to down
@return gear position (0 up, 1 down) */ @return gear position (0 up, 1 down) */
inline double GetGearPos(void) { return GearPos; } inline double GetGearPos(void) const { return GearPos; }
/** Gets the prop pitch position. /** Gets the prop pitch position.
@param engine engine ID number @param engine engine ID number
@return prop pitch position for the given engine in percent ( 0.0-1.0)*/ @return prop pitch position for the given engine in percent ( 0.0-1.0)*/
inline double GetPropAdvance(int engine) { return PropAdvance[engine]; } inline double GetPropAdvance(int engine) const { return PropAdvance[engine]; }
//@} //@}
/** Retrieves the State object pointer. /** Retrieves the State object pointer.
@ -336,11 +315,11 @@ public:
//@{ //@{
/** Sets the aileron command /** Sets the aileron command
@param cmd aileron command in percent*/ @param cmd aileron command in percent*/
inline void SetDaCmd(double cmd) { DaCmd = cmd; } inline void SetDaCmd( double cmd ) { DaCmd = cmd; }
/** Sets the elevator command /** Sets the elevator command
@param cmd elevator command in percent*/ @param cmd elevator command in percent*/
inline void SetDeCmd(double cmd) { DeCmd = cmd; } inline void SetDeCmd(double cmd ) { DeCmd = cmd; }
/** Sets the rudder command /** Sets the rudder command
@param cmd rudder command in percent*/ @param cmd rudder command in percent*/
@ -394,59 +373,38 @@ public:
//@{ //@{
/** Sets the left aileron position /** Sets the left aileron position
@param cmd left aileron position in radians*/ @param cmd left aileron position in radians*/
inline void SetDaLPos(double cmd) { DaLPos = cmd; } inline void SetDaLPos( int form , double pos )
{ DaLPos[form] = pos; }
/** Sets the normalized left aileron position
@param cmd left aileron position in percent (-1..1)*/
inline void SetDaLPosN(double cmd) { DaLPosN = cmd; }
/** Sets the right aileron position /** Sets the right aileron position
@param cmd right aileron position in radians*/ @param cmd right aileron position in radians*/
inline void SetDaRPos(double cmd) { DaRPos = cmd; } inline void SetDaRPos( int form , double pos )
{ DaRPos[form] = pos; }
/** Sets the normalized right aileron position
@param cmd right aileron position in percent (-1..1)*/
inline void SetDaRPosN(double cmd) { DaRPosN = cmd; }
/** Sets the elevator position /** Sets the elevator position
@param cmd elevator position in radians*/ @param cmd elevator position in radians*/
inline void SetDePos(double cmd) { DePos = cmd; } inline void SetDePos( int form , double pos )
{ DePos[form] = pos; }
/** Sets the normalized elevator position
@param cmd elevator position in percent (-1..1) */
inline void SetDePosN(double cmd) { DePosN = cmd; }
/** Sets the rudder position /** Sets the rudder position
@param cmd rudder position in radians*/ @param cmd rudder position in radians*/
inline void SetDrPos(double cmd) { DrPos = cmd; } inline void SetDrPos( int form , double pos )
{ DrPos[form] = pos; }
/** Sets the normalized rudder position
@param cmd rudder position in percent (-1..1)*/
inline void SetDrPosN(double cmd) { DrPosN = cmd; }
/** Sets the flaps position /** Sets the flaps position
@param cmd flaps position in radians*/ @param cmd flaps position in radians*/
inline void SetDfPos(double cmd) { DfPos = cmd; } inline void SetDfPos( int form , double pos )
{ DfPos[form] = pos; }
/** Sets the flaps position
@param cmd flaps position in radians*/
inline void SetDfPosN(double cmd) { DfPosN = cmd; }
/** Sets the speedbrake position /** Sets the speedbrake position
@param cmd speedbrake position in radians*/ @param cmd speedbrake position in radians*/
inline void SetDsbPos(double cmd) { DsbPos = cmd; } inline void SetDsbPos( int form , double pos )
{ DsbPos[form] = pos; }
/** Sets the normalized speedbrake position
@param cmd normalized speedbrake position in percent (-1..1)*/
inline void SetDsbPosN(double cmd) { DsbPosN = cmd; }
/** Sets the spoiler position /** Sets the spoiler position
@param cmd spoiler position in radians*/ @param cmd spoiler position in radians*/
inline void SetDspPos(double cmd) { DspPos = cmd; } inline void SetDspPos( int form , double pos )
{ DspPos[form] = pos; }
/** Sets the normalized spoiler position
@param cmd normalized spoiler position in percent (-1..1)*/
inline void SetDspPosN(double cmd) { DspPosN = cmd; }
/** Sets the actual throttle setting for the specified engine /** Sets the actual throttle setting for the specified engine
@param engine engine ID number @param engine engine ID number
@ -499,10 +457,14 @@ public:
void AddThrottle(void); void AddThrottle(void);
void bind(void);
void unbind(void);
private: private:
double DaCmd, DeCmd, DrCmd, DfCmd, DsbCmd, DspCmd; double DaCmd, DeCmd, DrCmd, DfCmd, DsbCmd, DspCmd;
double DaLPos, DaRPos, DePos, DrPos, DfPos, DsbPos, DspPos; double DePos[NForms], DaLPos[NForms], DaRPos[NForms], DrPos[NForms];
double DaLPosN, DaRPosN, DePosN, DrPosN, DfPosN, DsbPosN, DspPosN; double DfPos[NForms], DsbPos[NForms], DspPos[NForms];
double PTrimCmd, YTrimCmd, RTrimCmd; double PTrimCmd, YTrimCmd, RTrimCmd;
vector <double> ThrottleCmd; vector <double> ThrottleCmd;
vector <double> ThrottlePos; vector <double> ThrottlePos;
@ -517,7 +479,7 @@ private:
void Normalize(void); void Normalize(void);
vector <FGFCSComponent*> Components; vector <FGFCSComponent*> Components;
int ToNormalize[7]; int ToNormalize[NNorm];
void Debug(int from); void Debug(int from);
}; };

29
src/FDM/JSBSim/FGFDMExec.cpp
View file

@ -71,6 +71,7 @@ INCLUDES
#include "FGOutput.h" #include "FGOutput.h"
#include "FGConfigFile.h" #include "FGConfigFile.h"
#include "FGInitialCondition.h" #include "FGInitialCondition.h"
#include "FGPropertyManager.h"
static const char *IdSrc = "$Id$"; static const char *IdSrc = "$Id$";
static const char *IdHdr = ID_FDMEXEC; static const char *IdHdr = ID_FDMEXEC;
@ -87,8 +88,9 @@ CLASS IMPLEMENTATION
// Constructor // Constructor
FGFDMExec::FGFDMExec(void) FGFDMExec::FGFDMExec(FGPropertyManager* root)
{ {
Frame = 0; Frame = 0;
FirstModel = 0; FirstModel = 0;
Error = 0; Error = 0;
@ -122,16 +124,35 @@ FGFDMExec::FGFDMExec(void)
debug_lvl = 1; debug_lvl = 1;
} }
if(root == 0)
master= new FGPropertyManager;
else
master = root;
instance = master->GetNode("/fdm/jsbsim",IdFDM,true);
instance->SetDouble("zero",0);
Debug(0); Debug(0);
// this is here to catch errors in binding member functions
// to the property tree.
try {
Allocate(); Allocate();
} catch ( string msg ) {
cout << "Caught error: " << msg << endl;
exit(1);
}
} }
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
FGFDMExec::~FGFDMExec() FGFDMExec::~FGFDMExec()
{ {
try {
DeAllocate(); DeAllocate();
} catch ( string msg ) {
cout << "Caught error: " << msg << endl;
}
Debug(1); Debug(1);
} }
@ -488,6 +509,12 @@ bool FGFDMExec::ReadOutput(FGConfigFile* AC_cfg)
return true; return true;
} }
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
FGPropertyManager* FGFDMExec::GetPropertyManager(void) {
return instance;
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// The bitmasked value choices are as follows: // The bitmasked value choices are as follows:
// unset: In this case (the default) JSBSim would only print // unset: In this case (the default) JSBSim would only print

12
src/FDM/JSBSim/FGFDMExec.h
View file

@ -43,8 +43,9 @@ INCLUDES
#include "FGModel.h" #include "FGModel.h"
#include "FGInitialCondition.h" #include "FGInitialCondition.h"
#include "FGJSBBase.h" #include "FGJSBBase.h"
#include <vector> #include "FGPropertyManager.h"
#include <vector>
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
DEFINITIONS DEFINITIONS
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
@ -111,8 +112,10 @@ CLASS DECLARATION
class FGFDMExec : public FGJSBBase class FGFDMExec : public FGJSBBase
{ {
public: public:
/// Default constructor /// Default constructor
FGFDMExec(void); FGFDMExec(FGPropertyManager* root = 0);
/// Default destructor /// Default destructor
~FGFDMExec(); ~FGFDMExec();
@ -198,6 +201,8 @@ public:
/// Retrieves the aircraft path. /// Retrieves the aircraft path.
inline string GetAircraftPath(void) {return AircraftPath;} inline string GetAircraftPath(void) {return AircraftPath;}
FGPropertyManager* GetPropertyManager(void);
private: private:
FGModel* FirstModel; FGModel* FirstModel;
@ -209,6 +214,9 @@ private:
static unsigned int FDMctr; static unsigned int FDMctr;
bool modelLoaded; bool modelLoaded;
FGPropertyManager *master;
FGPropertyManager *instance;
string AircraftPath; string AircraftPath;
string EnginePath; string EnginePath;
string CFGVersion; string CFGVersion;

11
src/FDM/JSBSim/FGFactorGroup.cpp
View file

@ -70,7 +70,7 @@ CLASS IMPLEMENTATION
FGFactorGroup::FGFactorGroup( FGFDMExec* fdmex ) : FGCoefficient( fdmex) FGFactorGroup::FGFactorGroup( FGFDMExec* fdmex ) : FGCoefficient( fdmex)
{ {
FDMExec = fdmex; FDMExec = fdmex;
totalValue = 0;
Debug(0); Debug(0);
} }
@ -115,16 +115,17 @@ bool FGFactorGroup::Load(FGConfigFile *AC_cfg)
double FGFactorGroup::TotalValue(void) double FGFactorGroup::TotalValue(void)
{ {
unsigned int i; unsigned int i;
double totalsum = 0;
SDtotal = 0.0; SDtotal = 0.0;
totalValue = 0.0;
for (i=0; i<sum.size(); i++) { for (i=0; i<sum.size(); i++) {
totalsum += sum[i]->TotalValue(); totalValue += sum[i]->TotalValue();
SDtotal += sum[i]->GetSD(); SDtotal += sum[i]->GetSD();
} }
totalsum *= FGCoefficient::TotalValue(); //cout << totalValue << " " << FGCoefficient::TotalValue() << endl;
totalValue *= FGCoefficient::TotalValue();
SDtotal *= FGCoefficient::GetSD(); SDtotal *= FGCoefficient::GetSD();
Debug(2); Debug(2);
return totalsum; return totalValue;
} }
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/ /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

2
src/FDM/JSBSim/FGFactorGroup.h
View file

@ -99,6 +99,7 @@ class FGFactorGroup: public FGCoefficient {
bool Load(FGConfigFile *AC_cfg); bool Load(FGConfigFile *AC_cfg);
double TotalValue(void); double TotalValue(void);
inline double GetValue(void) const { return totalValue; }
//string GetCoefficientStrings(void); //string GetCoefficientStrings(void);
//string GetCoefficientValues(void); //string GetCoefficientValues(void);
inline double GetSD(void) { return SDtotal; } inline double GetSD(void) { return SDtotal; }
@ -111,6 +112,7 @@ class FGFactorGroup: public FGCoefficient {
typedef vector<FGCoefficient*> CoeffArray; typedef vector<FGCoefficient*> CoeffArray;
CoeffArray sum; CoeffArray sum;
double SDtotal; double SDtotal;
double totalValue;
void Debug(int from); void Debug(int from);
}; };

32
src/FDM/JSBSim/FGGroundReactions.cpp
View file

@ -36,6 +36,7 @@ INCLUDES
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#include "FGGroundReactions.h" #include "FGGroundReactions.h"
#include "FGPropertyManager.h"
static const char *IdSrc = "$Id$"; static const char *IdSrc = "$Id$";
static const char *IdHdr = ID_GROUNDREACTIONS; static const char *IdHdr = ID_GROUNDREACTIONS;
@ -49,6 +50,8 @@ FGGroundReactions::FGGroundReactions(FGFDMExec* fgex) : FGModel(fgex)
{ {
Name = "FGGroundReactions"; Name = "FGGroundReactions";
bind();
Debug(0); Debug(0);
} }
@ -56,6 +59,8 @@ FGGroundReactions::FGGroundReactions(FGFDMExec* fgex) : FGModel(fgex)
FGGroundReactions::~FGGroundReactions(void) FGGroundReactions::~FGGroundReactions(void)
{ {
unbind();
Debug(1); Debug(1);
} }
@ -204,3 +209,30 @@ void FGGroundReactions::Debug(int from)
} }
} }
void FGGroundReactions::bind(void){
PropertyManager->Tie("gear/num-units", this,
&FGGroundReactions::GetNumGearUnits);
PropertyManager->Tie("moments/l-gear-lbsft", this,1,
&FGGroundReactions::GetMoments);
PropertyManager->Tie("moments/m-gear-lbsft", this,2,
&FGGroundReactions::GetMoments);
PropertyManager->Tie("moments/n-gear-lbsft", this,3,
&FGGroundReactions::GetMoments);
PropertyManager->Tie("forces/fbx-gear-lbs", this,1,
&FGGroundReactions::GetForces);
PropertyManager->Tie("forces/fby-gear-lbs", this,2,
&FGGroundReactions::GetForces);
PropertyManager->Tie("forces/fbz-gear-lbs", this,3,
&FGGroundReactions::GetForces);
}
void FGGroundReactions::unbind(void){
PropertyManager->Untie("gear/num-units");
PropertyManager->Untie("moments/l-gear-lbsft");
PropertyManager->Untie("moments/m-gear-lbsft");
PropertyManager->Untie("moments/n-gear-lbsft");
PropertyManager->Untie("forces/fbx-gear-lbs");
PropertyManager->Untie("forces/fby-gear-lbs");
PropertyManager->Untie("forces/fbz-gear-lbs");
}

7
src/FDM/JSBSim/FGGroundReactions.h
View file

@ -74,11 +74,13 @@ public:
bool Run(void); bool Run(void);
bool Load(FGConfigFile* AC_cfg); bool Load(FGConfigFile* AC_cfg);
FGColumnVector3& GetForces(void) {return vForces;} FGColumnVector3& GetForces(void) {return vForces;}
double GetForces(int idx) const {return vForces(idx);}
FGColumnVector3& GetMoments(void) {return vMoments;} FGColumnVector3& GetMoments(void) {return vMoments;}
double GetMoments(int idx) const {return vMoments(idx);}
string GetGroundReactionStrings(void); string GetGroundReactionStrings(void);
string GetGroundReactionValues(void); string GetGroundReactionValues(void);
inline int GetNumGearUnits(void) { return lGear.size(); } inline int GetNumGearUnits(void) const { return lGear.size(); }
/** Gets a gear instance /** Gets a gear instance
@param gear index of gear instance @param gear index of gear instance
@return a pointer to the FGLGear instance of the gear unit requested */ @return a pointer to the FGLGear instance of the gear unit requested */
@ -86,6 +88,9 @@ public:
inline FGLGear* GetGearUnit(int gear) { return &(lGear[gear]); } inline FGLGear* GetGearUnit(int gear) { return &(lGear[gear]); }
void bind(void);
void unbind(void);
private: private:
vector <FGLGear> lGear; vector <FGLGear> lGear;
FGColumnVector3 vForces; FGColumnVector3 vForces;

17
src/FDM/JSBSim/FGInertial.cpp
View file

@ -60,6 +60,8 @@ FGInertial::FGInertial(FGFDMExec* fgex) : FGModel(fgex)
gAccelReference = GM/(RadiusReference*RadiusReference); gAccelReference = GM/(RadiusReference*RadiusReference);
gAccel = GM/(RadiusReference*RadiusReference); gAccel = GM/(RadiusReference*RadiusReference);
bind();
Debug(0); Debug(0);
} }
@ -67,6 +69,7 @@ FGInertial::FGInertial(FGFDMExec* fgex) : FGModel(fgex)
FGInertial::~FGInertial(void) FGInertial::~FGInertial(void)
{ {
unbind();
Debug(1); Debug(1);
} }
@ -168,3 +171,17 @@ void FGInertial::Debug(int from)
} }
} }
void FGInertial::bind(void){
PropertyManager->Tie("forces/fbx-inertial-lbs", this,1,
&FGInertial::GetForces);
PropertyManager->Tie("forces/fby-inertial-lbs", this,2,
&FGInertial::GetForces);
PropertyManager->Tie("forces/fbz-inertial-lbs", this,3,
&FGInertial::GetForces);
}
void FGInertial::unbind(void){
PropertyManager->Untie("forces/fbx-inertial-lbs");
PropertyManager->Untie("forces/fby-inertial-lbs");
PropertyManager->Untie("forces/fbz-inertial-lbs");
}

14
src/FDM/JSBSim/FGInertial.h
View file

@ -75,12 +75,16 @@ public:
bool Run(void); bool Run(void);
FGColumnVector3& GetForces(void) {return vForces;} FGColumnVector3& GetForces(void) {return vForces;}
FGColumnVector3& GetGravity(void) {return vGravity;} FGColumnVector3& GetGravity(void) {return vGravity;}
double GetForces(int n) {return vForces(n);} double GetForces(int n) const {return vForces(n);}
bool LoadInertial(FGConfigFile* AC_cfg); bool LoadInertial(FGConfigFile* AC_cfg);
double SLgravity(void) {return gAccelReference;} double SLgravity(void) const {return gAccelReference;}
double gravity(void) {return gAccel;} double gravity(void) const {return gAccel;}
double omega(void) {return RotationRate;} double omega(void) const {return RotationRate;}
double RefRadius(void) {return RadiusReference;} double RefRadius(void) const {return RadiusReference;}
void bind(void);
void unbind(void);
private: private:
FGColumnVector3 vOmegaLocal; FGColumnVector3 vOmegaLocal;

196
src/FDM/JSBSim/FGInitialCondition.cpp
View file

@ -54,6 +54,7 @@ INCLUDES
#include "FGAuxiliary.h" #include "FGAuxiliary.h"
#include "FGOutput.h" #include "FGOutput.h"
#include "FGConfigFile.h" #include "FGConfigFile.h"
#include "FGPropertyManager.h"
static const char *IdSrc = "$Id$"; static const char *IdSrc = "$Id$";
static const char *IdHdr = ID_INITIALCONDITION; static const char *IdHdr = ID_INITIALCONDITION;
@ -87,6 +88,8 @@ FGInitialCondition::FGInitialCondition(FGFDMExec *FDMExec)
fdmex=FDMExec; fdmex=FDMExec;
fdmex->GetPosition()->Seth(altitude); fdmex->GetPosition()->Seth(altitude);
fdmex->GetAtmosphere()->Run(); fdmex->GetAtmosphere()->Run();
PropertyManager=fdmex->GetPropertyManager();
bind();
} else { } else {
cout << "FGInitialCondition: This class requires a pointer to a valid FGFDMExec object" << endl; cout << "FGInitialCondition: This class requires a pointer to a valid FGFDMExec object" << endl;
} }
@ -98,6 +101,7 @@ FGInitialCondition::FGInitialCondition(FGFDMExec *FDMExec)
FGInitialCondition::~FGInitialCondition() FGInitialCondition::~FGInitialCondition()
{ {
unbind();
Debug(1); Debug(1);
} }
@ -814,3 +818,195 @@ void FGInitialCondition::Debug(int from)
} }
} }
void FGInitialCondition::bind(void){
PropertyManager->Tie("ic/vc-kts", this,
&FGInitialCondition::GetVcalibratedKtsIC,
&FGInitialCondition::SetVcalibratedKtsIC,
true);
PropertyManager->Tie("ic/ve-kts", this,
&FGInitialCondition::GetVequivalentKtsIC,
&FGInitialCondition::SetVequivalentKtsIC,
true);
PropertyManager->Tie("ic/vg-kts", this,
&FGInitialCondition::GetVgroundKtsIC,
&FGInitialCondition::SetVgroundKtsIC,
true);
PropertyManager->Tie("ic/vt-kts", this,
&FGInitialCondition::GetVtrueKtsIC,
&FGInitialCondition::SetVtrueKtsIC,
true);
PropertyManager->Tie("ic/mach-norm", this,
&FGInitialCondition::GetMachIC,
&FGInitialCondition::SetMachIC,
true);
PropertyManager->Tie("ic/roc-fpm", this,
&FGInitialCondition::GetClimbRateFpmIC,
&FGInitialCondition::SetClimbRateFpmIC,
true);
PropertyManager->Tie("ic/gamma-deg", this,
&FGInitialCondition::GetFlightPathAngleDegIC,
&FGInitialCondition::SetFlightPathAngleDegIC,
true);
PropertyManager->Tie("ic/alpha-deg", this,
&FGInitialCondition::GetAlphaDegIC,
&FGInitialCondition::SetAlphaDegIC,
true);
PropertyManager->Tie("ic/beta-deg", this,
&FGInitialCondition::GetBetaDegIC,
&FGInitialCondition::SetBetaDegIC,
true);
PropertyManager->Tie("ic/theta-deg", this,
&FGInitialCondition::GetPitchAngleDegIC,
&FGInitialCondition::SetPitchAngleDegIC,
true);
PropertyManager->Tie("ic/phi-deg", this,
&FGInitialCondition::GetRollAngleDegIC,
&FGInitialCondition::SetRollAngleDegIC,
true);
PropertyManager->Tie("ic/psi-true-deg", this,
&FGInitialCondition::GetHeadingDegIC );
PropertyManager->Tie("ic/lat-gc-deg", this,
&FGInitialCondition::GetLatitudeDegIC,
&FGInitialCondition::SetLatitudeDegIC,
true);
PropertyManager->Tie("ic/long-gc-deg", this,
&FGInitialCondition::GetLongitudeDegIC,
&FGInitialCondition::SetLongitudeDegIC,
true);
PropertyManager->Tie("ic/h-sl-ft", this,
&FGInitialCondition::GetAltitudeFtIC,
&FGInitialCondition::SetAltitudeFtIC,
true);
PropertyManager->Tie("ic/h-agl-ft", this,
&FGInitialCondition::GetAltitudeAGLFtIC,
&FGInitialCondition::SetAltitudeAGLFtIC,
true);
PropertyManager->Tie("ic/sea-level-radius-ft", this,
&FGInitialCondition::GetSeaLevelRadiusFtIC,
&FGInitialCondition::SetSeaLevelRadiusFtIC,
true);
PropertyManager->Tie("ic/terrain-altitude-ft", this,
&FGInitialCondition::GetTerrainAltitudeFtIC,
&FGInitialCondition::SetTerrainAltitudeFtIC,
true);
PropertyManager->Tie("ic/vg-fps", this,
&FGInitialCondition::GetVgroundFpsIC,
&FGInitialCondition::SetVgroundFpsIC,
true);
PropertyManager->Tie("ic/vt-fps", this,
&FGInitialCondition::GetVtrueFpsIC,
&FGInitialCondition::SetVtrueFpsIC,
true);
PropertyManager->Tie("ic/vw-bx-fps", this,
&FGInitialCondition::GetWindUFpsIC);
PropertyManager->Tie("ic/vw-by-fps", this,
&FGInitialCondition::GetWindVFpsIC);
PropertyManager->Tie("ic/vw-bz-fps", this,
&FGInitialCondition::GetWindWFpsIC);
PropertyManager->Tie("ic/vw-north-fps", this,
&FGInitialCondition::GetWindNFpsIC);
PropertyManager->Tie("ic/vw-east-fps", this,
&FGInitialCondition::GetWindEFpsIC);
PropertyManager->Tie("ic/vw-down-fps", this,
&FGInitialCondition::GetWindDFpsIC);
PropertyManager->Tie("ic/vw-mag-fps", this,
&FGInitialCondition::GetWindFpsIC);
/* PropertyManager->Tie("ic/vw-dir-deg", this,
&FGInitialCondition::GetWindDirDegIC,
&FGInitialCondition::SetWindDirDegIC,
true); */
PropertyManager->Tie("ic/roc-fps", this,
&FGInitialCondition::GetClimbRateFpsIC,
&FGInitialCondition::SetClimbRateFpsIC,
true);
/* PropertyManager->Tie("ic/u-fps", this,
&FGInitialCondition::GetUBodyFpsIC,
&FGInitialCondition::SetUBodyFpsIC,
true);
PropertyManager->Tie("ic/v-fps", this,
&FGInitialCondition::GetVBodyFpsIC,
&FGInitialCondition::SetVBodyFpsIC,
true);
PropertyManager->Tie("ic/w-fps", this,
&FGInitialCondition::GetWBodyFpsIC,
&FGInitialCondition::SetWBodyFpsIC,
true); */
PropertyManager->Tie("ic/gamma-rad", this,
&FGInitialCondition::GetFlightPathAngleRadIC,
&FGInitialCondition::SetFlightPathAngleRadIC,
true);
PropertyManager->Tie("ic/alpha-rad", this,
&FGInitialCondition::GetAlphaRadIC,
&FGInitialCondition::SetAlphaRadIC,
true);
PropertyManager->Tie("ic/theta-rad", this,
&FGInitialCondition::GetPitchAngleRadIC,
&FGInitialCondition::SetPitchAngleRadIC,
true);
PropertyManager->Tie("ic/beta-rad", this,
&FGInitialCondition::GetBetaRadIC,
&FGInitialCondition::SetBetaRadIC,
true);
PropertyManager->Tie("ic/phi-rad", this,
&FGInitialCondition::GetRollAngleRadIC,
&FGInitialCondition::SetRollAngleRadIC,
true);
PropertyManager->Tie("ic/psi-true-rad", this,
&FGInitialCondition::GetHeadingRadIC);
PropertyManager->Tie("ic/lat-gc-rad", this,
&FGInitialCondition::GetLatitudeRadIC,
&FGInitialCondition::SetLatitudeRadIC,
true);
PropertyManager->Tie("ic/long-gc-rad", this,
&FGInitialCondition::GetLongitudeRadIC,
&FGInitialCondition::SetLongitudeRadIC,
true);
}
void FGInitialCondition::unbind(void){
PropertyManager->Untie("ic/vc-kts");
PropertyManager->Untie("ic/ve-kts");
PropertyManager->Untie("ic/vg-kts");
PropertyManager->Untie("ic/vt-kts");
PropertyManager->Untie("ic/mach-norm");
PropertyManager->Untie("ic/roc-fpm");
PropertyManager->Untie("ic/gamma-deg");
PropertyManager->Untie("ic/alpha-deg");
PropertyManager->Untie("ic/beta-deg");
PropertyManager->Untie("ic/theta-deg");
PropertyManager->Untie("ic/phi-deg");
PropertyManager->Untie("ic/psi-true-deg");
PropertyManager->Untie("ic/lat-gc-deg");
PropertyManager->Untie("ic/long-gc-deg");
PropertyManager->Untie("ic/h-sl-ft");
PropertyManager->Untie("ic/h-agl-ft");
PropertyManager->Untie("ic/sea-level-radius-ft");
PropertyManager->Untie("ic/terrain-altitude-ft");
PropertyManager->Untie("ic/vg-fps");
PropertyManager->Untie("ic/vt-fps");
PropertyManager->Untie("ic/vw-bx-fps");
PropertyManager->Untie("ic/vw-by-fps");
PropertyManager->Untie("ic/vw-bz-fps");
PropertyManager->Untie("ic/vw-north-fps");
PropertyManager->Untie("ic/vw-east-fps");
PropertyManager->Untie("ic/vw-down-fps");
PropertyManager->Untie("ic/vw-mag-fps");
/* PropertyManager->Untie("ic/vw-dir-deg"); */
PropertyManager->Untie("ic/roc-fps");
/* PropertyManager->Untie("ic/u-fps");
PropertyManager->Untie("ic/v-fps");
PropertyManager->Untie("ic/w-fps"); */
PropertyManager->Untie("ic/gamma-rad");
PropertyManager->Untie("ic/alpha-rad");
PropertyManager->Untie("ic/theta-rad");
PropertyManager->Untie("ic/beta-rad");
PropertyManager->Untie("ic/phi-rad");
PropertyManager->Untie("ic/psi-true-rad");
PropertyManager->Untie("ic/lat-gc-rad");
PropertyManager->Untie("ic/long-gc-rad");
}

83
src/FDM/JSBSim/FGInitialCondition.h
View file

@ -166,30 +166,30 @@ public:
inline void SetLongitudeDegIC(double tt) { longitude=tt*degtorad; } inline void SetLongitudeDegIC(double tt) { longitude=tt*degtorad; }
inline double GetVcalibratedKtsIC(void) { return vc*fpstokts; } inline double GetVcalibratedKtsIC(void) const { return vc*fpstokts; }
inline double GetVequivalentKtsIC(void) { return ve*fpstokts; } inline double GetVequivalentKtsIC(void) const { return ve*fpstokts; }
inline double GetVgroundKtsIC(void) { return vg*fpstokts; } inline double GetVgroundKtsIC(void) const { return vg*fpstokts; }
inline double GetVtrueKtsIC(void) { return vt*fpstokts; } inline double GetVtrueKtsIC(void) const { return vt*fpstokts; }
inline double GetMachIC(void) { return mach; } inline double GetMachIC(void) const { return mach; }
inline double GetClimbRateFpmIC(void) { return hdot*60; } inline double GetClimbRateFpmIC(void) const { return hdot*60; }
inline double GetFlightPathAngleDegIC(void) { return gamma*radtodeg; } inline double GetFlightPathAngleDegIC(void)const { return gamma*radtodeg; }
inline double GetAlphaDegIC(void) { return alpha*radtodeg; } inline double GetAlphaDegIC(void) const { return alpha*radtodeg; }
inline double GetBetaDegIC(void) { return beta*radtodeg; } inline double GetBetaDegIC(void) const { return beta*radtodeg; }
inline double GetPitchAngleDegIC(void) { return theta*radtodeg; } inline double GetPitchAngleDegIC(void) const { return theta*radtodeg; }
inline double GetRollAngleDegIC(void) { return phi*radtodeg; } inline double GetRollAngleDegIC(void) const { return phi*radtodeg; }
inline double GetHeadingDegIC(void) { return psi*radtodeg; } inline double GetHeadingDegIC(void) const { return psi*radtodeg; }
inline double GetLatitudeDegIC(void) { return latitude*radtodeg; } inline double GetLatitudeDegIC(void) const { return latitude*radtodeg; }
inline double GetLongitudeDegIC(void) { return longitude*radtodeg; } inline double GetLongitudeDegIC(void) const { return longitude*radtodeg; }
inline double GetAltitudeFtIC(void) { return altitude; } inline double GetAltitudeFtIC(void) const { return altitude; }
inline double GetAltitudeAGLFtIC(void) { return altitude - terrain_altitude; } inline double GetAltitudeAGLFtIC(void) const { return altitude - terrain_altitude; }
inline double GetSeaLevelRadiusFtIC(void) { return sea_level_radius; } inline double GetSeaLevelRadiusFtIC(void) const { return sea_level_radius; }
inline double GetTerrainAltitudeFtIC(void) { return terrain_altitude; } inline double GetTerrainAltitudeFtIC(void) const { return terrain_altitude; }
void SetVgroundFpsIC(double tt); void SetVgroundFpsIC(double tt);
void SetVtrueFpsIC(double tt); void SetVtrueFpsIC(double tt);
@ -211,17 +211,17 @@ public:
void SetWindDownKtsIC(double wD); void SetWindDownKtsIC(double wD);
void SetClimbRateFpsIC(double tt); void SetClimbRateFpsIC(double tt);
inline double GetVgroundFpsIC(void) { return vg; } inline double GetVgroundFpsIC(void) const { return vg; }
inline double GetVtrueFpsIC(void) { return vt; } inline double GetVtrueFpsIC(void) const { return vt; }
inline double GetWindUFpsIC(void) { return uw; } inline double GetWindUFpsIC(void) const { return uw; }
inline double GetWindVFpsIC(void) { return vw; } inline double GetWindVFpsIC(void) const { return vw; }
inline double GetWindWFpsIC(void) { return ww; } inline double GetWindWFpsIC(void) const { return ww; }
inline double GetWindNFpsIC(void) { return wnorth; } inline double GetWindNFpsIC(void) const { return wnorth; }
inline double GetWindEFpsIC(void) { return weast; } inline double GetWindEFpsIC(void) const { return weast; }
inline double GetWindDFpsIC(void) { return wdown; } inline double GetWindDFpsIC(void) const { return wdown; }
inline double GetWindFpsIC(void) { return sqrt(wnorth*wnorth + weast*weast); } inline double GetWindFpsIC(void) const { return sqrt(wnorth*wnorth + weast*weast); }
double GetWindDirDegIC(void); double GetWindDirDegIC(void);
inline double GetClimbRateFpsIC(void) { return hdot; } inline double GetClimbRateFpsIC(void) const { return hdot; }
double GetUBodyFpsIC(void); double GetUBodyFpsIC(void);
double GetVBodyFpsIC(void); double GetVBodyFpsIC(void);
double GetWBodyFpsIC(void); double GetWBodyFpsIC(void);
@ -233,23 +233,27 @@ public:
void SetTrueHeadingRadIC(double tt); void SetTrueHeadingRadIC(double tt);
inline void SetLatitudeRadIC(double tt) { latitude=tt; } inline void SetLatitudeRadIC(double tt) { latitude=tt; }
inline void SetLongitudeRadIC(double tt) { longitude=tt; } inline void SetLongitudeRadIC(double tt) { longitude=tt; }
inline double GetFlightPathAngleRadIC(void) { return gamma; } inline double GetFlightPathAngleRadIC(void) const { return gamma; }
inline double GetAlphaRadIC(void) { return alpha; } inline double GetAlphaRadIC(void) const { return alpha; }
inline double GetPitchAngleRadIC(void) { return theta; } inline double GetPitchAngleRadIC(void) const { return theta; }
inline double GetBetaRadIC(void) { return beta; } inline double GetBetaRadIC(void) const { return beta; }
inline double GetRollAngleRadIC(void) { return phi; } inline double GetRollAngleRadIC(void) const { return phi; }
inline double GetHeadingRadIC(void) { return psi; } inline double GetHeadingRadIC(void) const { return psi; }
inline double GetLatitudeRadIC(void) { return latitude; } inline double GetLatitudeRadIC(void) const { return latitude; }
inline double GetLongitudeRadIC(void) { return longitude; } inline double GetLongitudeRadIC(void) const { return longitude; }
inline double GetThetaRadIC(void) { return theta; } inline double GetThetaRadIC(void) const { return theta; }
inline double GetPhiRadIC(void) { return phi; } inline double GetPhiRadIC(void) const { return phi; }
inline double GetPsiRadIC(void) { return psi; } inline double GetPsiRadIC(void) const { return psi; }
inline speedset GetSpeedSet(void) { return lastSpeedSet; } inline speedset GetSpeedSet(void) { return lastSpeedSet; }
inline windset GetWindSet(void) { return lastWindSet; } inline windset GetWindSet(void) { return lastWindSet; }
bool Load(string acpath, string acname, string rstname); bool Load(string acpath, string acname, string rstname);
void bind(void);
void unbind(void);
private: private:
double vt,vc,ve,vg; double vt,vc,ve,vg;
double mach; double mach;
@ -277,6 +281,7 @@ private:
windset lastWindSet; windset lastWindSet;
FGFDMExec *fdmex; FGFDMExec *fdmex;
FGPropertyManager *PropertyManager;
bool getAlpha(void); bool getAlpha(void);
bool getTheta(void); bool getTheta(void);

48
src/FDM/JSBSim/FGMassBalance.cpp
View file

@ -39,6 +39,7 @@ INCLUDES
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#include "FGMassBalance.h" #include "FGMassBalance.h"
#include "FGPropertyManager.h"
static const char *IdSrc = "$Id$"; static const char *IdSrc = "$Id$";
static const char *IdHdr = ID_MASSBALANCE; static const char *IdHdr = ID_MASSBALANCE;
@ -51,6 +52,7 @@ CLASS IMPLEMENTATION
FGMassBalance::FGMassBalance(FGFDMExec* fdmex) : FGModel(fdmex) FGMassBalance::FGMassBalance(FGFDMExec* fdmex) : FGModel(fdmex)
{ {
Name = "FGMassBalance"; Name = "FGMassBalance";
bind();
Debug(0); Debug(0);
} }
@ -59,6 +61,7 @@ FGMassBalance::FGMassBalance(FGFDMExec* fdmex) : FGModel(fdmex)
FGMassBalance::~FGMassBalance() FGMassBalance::~FGMassBalance()
{ {
unbind();
Debug(1); Debug(1);
} }
@ -131,7 +134,7 @@ double FGMassBalance::GetPMIxx(void)
{ {
double I = 0.0; double I = 0.0;
for (unsigned int i=0; i<PointMassLoc.size(); i++) { for (unsigned int i=0; i<PointMassLoc.size(); i++) {
I += PointMassLoc[i](eX)*PointMassLoc[i](eX)*PointMassWeight[i]; I += (PointMassLoc[i](eX)-vXYZcg(eX))*(PointMassLoc[i](eX)-vXYZcg(eX))*PointMassWeight[i];
} }
I /= (144.0*Inertial->gravity()); I /= (144.0*Inertial->gravity());
return I; return I;
@ -143,7 +146,7 @@ double FGMassBalance::GetPMIyy(void)
{ {
double I = 0.0; double I = 0.0;
for (unsigned int i=0; i<PointMassLoc.size(); i++) { for (unsigned int i=0; i<PointMassLoc.size(); i++) {
I += PointMassLoc[i](eY)*PointMassLoc[i](eY)*PointMassWeight[i]; I += (PointMassLoc[i](eY)-vXYZcg(eY))*(PointMassLoc[i](eY)-vXYZcg(eY))*PointMassWeight[i];
} }
I /= (144.0*Inertial->gravity()); I /= (144.0*Inertial->gravity());
return I; return I;
@ -155,7 +158,7 @@ double FGMassBalance::GetPMIzz(void)
{ {
double I = 0.0; double I = 0.0;
for (unsigned int i=0; i<PointMassLoc.size(); i++) { for (unsigned int i=0; i<PointMassLoc.size(); i++) {
I += PointMassLoc[i](eZ)*PointMassLoc[i](eZ)*PointMassWeight[i]; I += (PointMassLoc[i](eZ)-vXYZcg(eZ))*(PointMassLoc[i](eZ)-vXYZcg(eZ))*PointMassWeight[i];
} }
I /= (144.0*Inertial->gravity()); I /= (144.0*Inertial->gravity());
return I; return I;
@ -167,7 +170,7 @@ double FGMassBalance::GetPMIxy(void)
{ {
double I = 0.0; double I = 0.0;
for (unsigned int i=0; i<PointMassLoc.size(); i++) { for (unsigned int i=0; i<PointMassLoc.size(); i++) {
I += PointMassLoc[i](eX)*PointMassLoc[i](eY)*PointMassWeight[i]; I += (PointMassLoc[i](eX)-vXYZcg(eX))*(PointMassLoc[i](eY)-vXYZcg(eY))*PointMassWeight[i];
} }
I /= (144.0*Inertial->gravity()); I /= (144.0*Inertial->gravity());
return I; return I;
@ -179,7 +182,7 @@ double FGMassBalance::GetPMIxz(void)
{ {
double I = 0.0; double I = 0.0;
for (unsigned int i=0; i<PointMassLoc.size(); i++) { for (unsigned int i=0; i<PointMassLoc.size(); i++) {
I += PointMassLoc[i](eX)*PointMassLoc[i](eZ)*PointMassWeight[i]; I += (PointMassLoc[i](eX)-vXYZcg(eX))*(PointMassLoc[i](eZ)-vXYZcg(eZ))*PointMassWeight[i];
} }
I /= (144.0*Inertial->gravity()); I /= (144.0*Inertial->gravity());
return I; return I;
@ -239,3 +242,38 @@ void FGMassBalance::Debug(int from)
} }
} }
void FGMassBalance::bind(void){
PropertyManager->Tie("inertia/mass-slugs", this,
&FGMassBalance::GetMass);
PropertyManager->Tie("inertia/weight-lbs", this,
&FGMassBalance::GetWeight);
PropertyManager->Tie("inertia/ixx-lbsft2", this,
&FGMassBalance::GetIxx);
PropertyManager->Tie("inertia/iyy-lbsft2", this,
&FGMassBalance::GetIyy);
PropertyManager->Tie("inertia/izz-lbsft2", this,
&FGMassBalance::GetIzz);
PropertyManager->Tie("inertia/ixy-lbsft2", this,
&FGMassBalance::GetIxy);
PropertyManager->Tie("inertia/ixz-lbsft2", this,
&FGMassBalance::GetIxz);
PropertyManager->Tie("inertia/cg-x-ft", this,1,
&FGMassBalance::GetXYZcg);
PropertyManager->Tie("inertia/cg-y-ft", this,2,
&FGMassBalance::GetXYZcg);
PropertyManager->Tie("inertia/cg-z-ft", this,3,
&FGMassBalance::GetXYZcg);
}
void FGMassBalance::unbind(void){
PropertyManager->Untie("inertia/mass-slugs");
PropertyManager->Untie("inertia/weight-lbs");
PropertyManager->Untie("inertia/ixx-lbsft2");
PropertyManager->Untie("inertia/iyy-lbsft2");
PropertyManager->Untie("inertia/izz-lbsft2");
PropertyManager->Untie("inertia/ixy-lbsft2");
PropertyManager->Untie("inertia/ixz-lbsft2");
PropertyManager->Untie("inertia/cg-x-ft");
PropertyManager->Untie("inertia/cg-y-ft");
PropertyManager->Untie("inertia/cg-z-ft");
}

19
src/FDM/JSBSim/FGMassBalance.h
View file

@ -61,15 +61,15 @@ public:
bool Run(void); bool Run(void);
inline double GetMass(void) {return Mass;} inline double GetMass(void) const {return Mass;}
inline double GetWeight(void) {return Weight;} inline double GetWeight(void) const {return Weight;}
inline double GetIxx(void) {return Ixx;} inline double GetIxx(void) const {return Ixx;}
inline double GetIyy(void) {return Iyy;} inline double GetIyy(void) const {return Iyy;}
inline double GetIzz(void) {return Izz;} inline double GetIzz(void) const {return Izz;}
inline double GetIxy(void) {return Ixy;} inline double GetIxy(void) const {return Ixy;}
inline double GetIxz(void) {return Ixz;} inline double GetIxz(void) const {return Ixz;}
inline FGColumnVector3& GetXYZcg(void) {return vXYZcg;} inline FGColumnVector3& GetXYZcg(void) {return vXYZcg;}
inline double GetXYZcg(int axis) {return vXYZcg(axis);} inline double GetXYZcg(int axis) const {return vXYZcg(axis);}
inline void SetEmptyWeight(double EW) { EmptyWeight = EW;} inline void SetEmptyWeight(double EW) { EmptyWeight = EW;}
inline void SetBaseIxx(double bixx) { baseIxx = bixx;} inline void SetBaseIxx(double bixx) { baseIxx = bixx;}
@ -88,6 +88,9 @@ public:
double GetPMIxy(void); double GetPMIxy(void);
double GetPMIxz(void); double GetPMIxz(void);
void bind(void);
void unbind(void);
private: private:
double Weight; double Weight;
double EmptyWeight; double EmptyWeight;

6
src/FDM/JSBSim/FGModel.cpp
View file

@ -86,6 +86,12 @@ FGModel::FGModel(FGFDMExec* fdmex)
Auxiliary = 0; Auxiliary = 0;
Output = 0; Output = 0;
//in order for FGModel derived classes to self-bind (that is, call
//their bind function in the constructor, the PropertyManager pointer
//must be brought up now.
PropertyManager = FDMExec->GetPropertyManager();
exe_ctr = 1; exe_ctr = 1;
if (debug_lvl & 2) cout << " FGModel Base Class" << endl; if (debug_lvl & 2) cout << " FGModel Base Class" << endl;

4
src/FDM/JSBSim/FGModel.h
View file

@ -39,6 +39,7 @@ INCLUDES
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#include "FGJSBBase.h" #include "FGJSBBase.h"
#include "FGPropertyManager.h"
#ifdef FGFS #ifdef FGFS
# include <simgear/compiler.h> # include <simgear/compiler.h>
@ -127,6 +128,8 @@ public:
virtual void SetRate(int tt) {rate = tt;} virtual void SetRate(int tt) {rate = tt;}
virtual int GetRate(void) {return rate;} virtual int GetRate(void) {return rate;}
void SetPropertyManager(FGPropertyManager *fgpm) { PropertyManager=fgpm;}
protected: protected:
int exe_ctr; int exe_ctr;
int rate; int rate;
@ -148,6 +151,7 @@ protected:
FGPosition* Position; FGPosition* Position;
FGAuxiliary* Auxiliary; FGAuxiliary* Auxiliary;
FGOutput* Output; FGOutput* Output;
FGPropertyManager* PropertyManager;
}; };
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

69
src/FDM/JSBSim/FGPosition.cpp
View file

@ -83,6 +83,8 @@ INCLUDES
#include "FGRotation.h" #include "FGRotation.h"
#include "FGAuxiliary.h" #include "FGAuxiliary.h"
#include "FGOutput.h" #include "FGOutput.h"
#include "FGPropertyManager.h"
static const char *IdSrc = "$Id$"; static const char *IdSrc = "$Id$";
static const char *IdHdr = ID_POSITION; static const char *IdHdr = ID_POSITION;
@ -104,7 +106,7 @@ FGPosition::FGPosition(FGFDMExec* fdmex) : FGModel(fdmex)
gamma = Vt = Vground = 0.0; gamma = Vt = Vground = 0.0;
hoverbmac = hoverbcg = 0.0; hoverbmac = hoverbcg = 0.0;
psigt = 0.0; psigt = 0.0;
bind();
Debug(0); Debug(0);
} }
@ -112,6 +114,7 @@ FGPosition::FGPosition(FGFDMExec* fdmex) : FGModel(fdmex)
FGPosition::~FGPosition(void) FGPosition::~FGPosition(void)
{ {
unbind();
Debug(1); Debug(1);
} }
@ -271,3 +274,67 @@ void FGPosition::Debug(int from)
} }
} }
void FGPosition::bind(void){
PropertyManager->Tie("velocities/v-north-fps", this,
&FGPosition::GetVn);
PropertyManager->Tie("velocities/v-east-fps", this,
&FGPosition::GetVe);
PropertyManager->Tie("velocities/v-down-fps", this,
&FGPosition::GetVd);
PropertyManager->Tie("velocities/vg-fps", this,
&FGPosition::GetVground);
PropertyManager->Tie("flight-path/psi-gt-rad", this,
&FGPosition::GetGroundTrack);
PropertyManager->Tie("position/h-sl-ft", this,
&FGPosition::Geth,
&FGPosition::Seth,
true);
PropertyManager->Tie("postition/h-dot-fps", this,
&FGPosition::Gethdot);
PropertyManager->Tie("postition/lat-gc-rad", this,
&FGPosition::GetLatitude,
&FGPosition::SetLatitude);
PropertyManager->Tie("postition/lat-dot-gc-rad", this,
&FGPosition::GetLatitudeDot);
PropertyManager->Tie("postition/long-gc-rad", this,
&FGPosition::GetLongitude,
&FGPosition::SetLongitude,
true);
PropertyManager->Tie("postition/long-dot-gc-rad", this,
&FGPosition::GetLongitudeDot);
PropertyManager->Tie("metrics/runway-radius", this,
&FGPosition::GetRunwayRadius,
&FGPosition::SetRunwayRadius);
PropertyManager->Tie("position/h-agl-ft", this,
&FGPosition::GetDistanceAGL,
&FGPosition::SetDistanceAGL);
PropertyManager->Tie("position/radius-to-vehicle-ft", this,
&FGPosition::GetRadius);
PropertyManager->Tie("flight-path/gamma-rad", this,
&FGPosition::GetGamma,
&FGPosition::SetGamma);
PropertyManager->Tie("position/h_b-cg-ft", this,
&FGPosition::GetHOverBCG);
PropertyManager->Tie("position/h_b-mac-ft", this,
&FGPosition::GetHOverBMAC);
}
void FGPosition::unbind(void){
PropertyManager->Untie("velocities/v-north-fps");
PropertyManager->Untie("velocities/v-east-fps");
PropertyManager->Untie("velocities/v-down-fps");
PropertyManager->Untie("velocities/vg-fps");
PropertyManager->Untie("flight-path/psi-gt-rad");
PropertyManager->Untie("position/h-sl-ft");
PropertyManager->Untie("postition/h-dot-fps");
PropertyManager->Untie("postition/lat-gc-rad");
PropertyManager->Untie("postition/lat-dot-gc-rad");
PropertyManager->Untie("postition/long-gc-rad");
PropertyManager->Untie("postition/long-dot-gc-rad");
PropertyManager->Untie("metrics/runway-radius");
PropertyManager->Untie("position/h-agl-ft");
PropertyManager->Untie("position/radius-to-vehicle-ft");
PropertyManager->Untie("flight-path/gamma-rad");
PropertyManager->Untie("position/h_b-cg-ft");
PropertyManager->Untie("position/h_b-mac-ft");
}

37
src/FDM/JSBSim/FGPosition.h
View file

@ -87,26 +87,26 @@ public:
inline FGColumnVector3& GetVel(void) { return vVel; } inline FGColumnVector3& GetVel(void) { return vVel; }
inline FGColumnVector3& GetVelDot(void) { return vVelDot; } inline FGColumnVector3& GetVelDot(void) { return vVelDot; }
inline double GetVn(void) { return vVel(eX); } inline double GetVn(void) const { return vVel(eX); }
inline double GetVe(void) { return vVel(eY); } inline double GetVe(void) const { return vVel(eY); }
inline double GetVd(void) { return vVel(eZ); } inline double GetVd(void) const { return vVel(eZ); }
inline double GetVground(void) { return Vground; } inline double GetVground(void) const { return Vground; }
inline double GetGroundTrack(void) { return psigt; } inline double GetGroundTrack(void) const { return psigt; }
inline double Geth(void) { return h; } inline double Geth(void) const { return h; }
inline double Gethdot(void) { return RadiusDot; } inline double Gethdot(void) const { return RadiusDot; }
inline double GetLatitude(void) { return Latitude; } inline double GetLatitude(void) const { return Latitude; }
inline double GetLatitudeDot(void) { return LatitudeDot; } inline double GetLatitudeDot(void) const { return LatitudeDot; }
inline double GetLongitude(void) { return Longitude; } inline double GetLongitude(void) const { return Longitude; }
inline double GetLongitudeDot(void) { return LongitudeDot; } inline double GetLongitudeDot(void) const { return LongitudeDot; }
inline double GetRunwayRadius(void) { return RunwayRadius; } inline double GetRunwayRadius(void) const { return RunwayRadius; }
inline double GetDistanceAGL(void) { return DistanceAGL; } inline double GetDistanceAGL(void) const { return DistanceAGL; }
inline double GetRadius(void) { return Radius; } inline double GetRadius(void) const { return Radius; }
inline FGColumnVector3& GetRunwayNormal(void) { return vRunwayNormal; } inline FGColumnVector3& GetRunwayNormal(void) { return vRunwayNormal; }
inline double GetGamma(void) { return gamma; } inline double GetGamma(void) const { return gamma; }
inline void SetGamma(double tt) { gamma = tt; } inline void SetGamma(double tt) { gamma = tt; }
inline double GetHOverBCG(void) { return hoverbcg; } inline double GetHOverBCG(void) const { return hoverbcg; }
inline double GetHOverBMAC(void){ return hoverbmac; } inline double GetHOverBMAC(void) const { return hoverbmac; }
void SetvVel(const FGColumnVector3& v) { vVel = v; } void SetvVel(const FGColumnVector3& v) { vVel = v; }
void SetLatitude(double tt) { Latitude = tt; } void SetLatitude(double tt) { Latitude = tt; }
void SetLongitude(double tt) { Longitude = tt; } void SetLongitude(double tt) { Longitude = tt; }
@ -118,6 +118,9 @@ public:
vRunwayNormal << fgx << fgy << fgz; vRunwayNormal << fgx << fgy << fgz;
} }
void bind(void);
void unbind(void);
private: private:
FGColumnVector3 vVel; FGColumnVector3 vVel;
FGColumnVector3 vVelDot; FGColumnVector3 vVelDot;

43
src/FDM/JSBSim/FGPropulsion.cpp
View file

@ -53,6 +53,8 @@ INCLUDES
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#include "FGPropulsion.h" #include "FGPropulsion.h"
#include "FGPropertyManager.h"
static const char *IdSrc = "$Id$"; static const char *IdSrc = "$Id$";
static const char *IdHdr = ID_PROPULSION; static const char *IdHdr = ID_PROPULSION;
@ -67,7 +69,7 @@ FGPropulsion::FGPropulsion(FGFDMExec* exec) : FGModel(exec)
numSelectedFuelTanks = numSelectedOxiTanks = 0; numSelectedFuelTanks = numSelectedOxiTanks = 0;
numTanks = numEngines = numThrusters = 0; numTanks = numEngines = numThrusters = 0;
numOxiTanks = numFuelTanks = 0; numOxiTanks = numFuelTanks = 0;
bind();
Debug(0); Debug(0);
} }
@ -77,6 +79,7 @@ FGPropulsion::~FGPropulsion()
{ {
for (unsigned int i=0; i<Engines.size(); i++) delete Engines[i]; for (unsigned int i=0; i<Engines.size(); i++) delete Engines[i];
Engines.clear(); Engines.clear();
unbind();
Debug(1); Debug(1);
} }
@ -588,3 +591,41 @@ void FGPropulsion::Debug(int from)
} }
} }
void FGPropulsion::bind(void){
/* PropertyManager->Tie("propulsion/num-engines", this,
&FGPropulsion::GetNumEngines);
PropertyManager->Tie("propulsion/num-tanks", this,
&FGPropulsion::GetNumTanks); */
PropertyManager->Tie("propulsion/num-sel-fuel-tanks", this,
&FGPropulsion::GetnumSelectedFuelTanks);
PropertyManager->Tie("propulsion/num-sel-ox-tanks", this,
&FGPropulsion::GetnumSelectedOxiTanks);
PropertyManager->Tie("propulsion/fbx-prop-lbs", this,1,
&FGPropulsion::GetForces);
PropertyManager->Tie("propulsion/fby-prop-lbs", this,2,
&FGPropulsion::GetForces);
PropertyManager->Tie("propulsion/fbz-prop-lbs", this,3,
&FGPropulsion::GetForces);
PropertyManager->Tie("propulsion/l-prop-lbsft", this,1,
&FGPropulsion::GetMoments);
PropertyManager->Tie("propulsion/m-prop-lbsft", this,2,
&FGPropulsion::GetMoments);
PropertyManager->Tie("propulsion/n-prop-lbsft", this,3,
&FGPropulsion::GetMoments);
//PropertyManager->Tie("propulsion/tanks-weight-lbs", this,
// &FGPropulsion::GetTanksWeight);
}
void FGPropulsion::unbind(void){
/* PropertyManager->Untie("propulsion/num-engines");
PropertyManager->Untie("propulsion/num-tanks"); */
PropertyManager->Untie("propulsion/num-sel-fuel-tanks");
PropertyManager->Untie("propulsion/num-sel-ox-tanks");
PropertyManager->Untie("propulsion/fbx-prop-lbs");
PropertyManager->Untie("propulsion/fby-prop-lbs");
PropertyManager->Untie("propulsion/fbz-prop-lbs");
PropertyManager->Untie("propulsion/l-prop-lbsft");
PropertyManager->Untie("propulsion/m-prop-lbsft");
PropertyManager->Untie("propulsion/n-prop-lbsft");
//PropertyManager->Untie("propulsion/tanks-weight-lbs");
}

15
src/FDM/JSBSim/FGPropulsion.h
View file

@ -126,7 +126,7 @@ public:
bool Load(FGConfigFile* AC_cfg); bool Load(FGConfigFile* AC_cfg);
/// Retrieves the number of engines defined for the aircraft. /// Retrieves the number of engines defined for the aircraft.
inline unsigned int GetNumEngines(void) {return Engines.size();} inline unsigned int GetNumEngines(void) const {return Engines.size();}
/** Retrieves an engine object pointer from the list of engines. /** Retrieves an engine object pointer from the list of engines.
@param index the engine index within the vector container @param index the engine index within the vector container
@ -137,7 +137,7 @@ public:
else return 0L; } else return 0L; }
// Retrieves the number of tanks defined for the aircraft. // Retrieves the number of tanks defined for the aircraft.
inline unsigned int GetNumTanks(void) {return Tanks.size();} inline unsigned int GetNumTanks(void) const {return Tanks.size();}
/** Retrieves a tank object pointer from the list of tanks. /** Retrieves a tank object pointer from the list of tanks.
@param index the tank index within the vector container @param index the tank index within the vector container
@ -156,10 +156,10 @@ public:
else return 0L; } else return 0L; }
/** Returns the number of fuel tanks currently actively supplying fuel */ /** Returns the number of fuel tanks currently actively supplying fuel */
inline int GetnumSelectedFuelTanks(void) {return numSelectedFuelTanks;} inline int GetnumSelectedFuelTanks(void) const {return numSelectedFuelTanks;}
/** Returns the number of oxidizer tanks currently actively supplying oxidizer */ /** Returns the number of oxidizer tanks currently actively supplying oxidizer */
inline int GetnumSelectedOxiTanks(void) {return numSelectedOxiTanks;} inline int GetnumSelectedOxiTanks(void) const {return numSelectedOxiTanks;}
/** Loops the engines/thrusters until thrust output steady (used for trimming) */ /** Loops the engines/thrusters until thrust output steady (used for trimming) */
bool GetSteadyState(void); bool GetSteadyState(void);
@ -172,9 +172,9 @@ public:
string GetPropulsionValues(void); string GetPropulsionValues(void);
inline FGColumnVector3& GetForces(void) {return vForces; } inline FGColumnVector3& GetForces(void) {return vForces; }
inline double GetForces(int n) { return vForces(n);} inline double GetForces(int n) const { return vForces(n);}
inline FGColumnVector3& GetMoments(void) {return vMoments;} inline FGColumnVector3& GetMoments(void) {return vMoments;}
inline double GetMoments(int n) {return vMoments(n);} inline double GetMoments(int n) const {return vMoments(n);}
FGColumnVector3& GetTanksCG(void); FGColumnVector3& GetTanksCG(void);
double GetTanksWeight(void); double GetTanksWeight(void);
@ -185,6 +185,9 @@ public:
double GetTanksIxz(const FGColumnVector3& vXYZcg); double GetTanksIxz(const FGColumnVector3& vXYZcg);
double GetTanksIxy(const FGColumnVector3& vXYZcg); double GetTanksIxy(const FGColumnVector3& vXYZcg);
void bind();
void unbind();
private: private:
vector <FGEngine*> Engines; vector <FGEngine*> Engines;
vector <FGTank*> Tanks; vector <FGTank*> Tanks;

64
src/FDM/JSBSim/FGRotation.cpp
View file

@ -66,6 +66,8 @@ INCLUDES
#include "FGPosition.h" #include "FGPosition.h"
#include "FGAuxiliary.h" #include "FGAuxiliary.h"
#include "FGOutput.h" #include "FGOutput.h"
#include "FGPropertyManager.h"
static const char *IdSrc = "$Id$"; static const char *IdSrc = "$Id$";
static const char *IdHdr = ID_ROTATION; static const char *IdHdr = ID_ROTATION;
@ -81,6 +83,8 @@ FGRotation::FGRotation(FGFDMExec* fdmex) : FGModel(fdmex)
cTht=cPhi=cPsi=1.0; cTht=cPhi=cPsi=1.0;
sTht=sPhi=sPsi=0.0; sTht=sPhi=sPsi=0.0;
bind();
Debug(0); Debug(0);
} }
@ -88,6 +92,7 @@ FGRotation::FGRotation(FGFDMExec* fdmex) : FGModel(fdmex)
FGRotation::~FGRotation() FGRotation::~FGRotation()
{ {
unbind();
Debug(1); Debug(1);
} }
@ -203,3 +208,62 @@ void FGRotation::Debug(int from)
} }
} }
void FGRotation::bind(void){
PropertyManager->Tie("velocities/p-rad_sec", this,1,
&FGRotation::GetPQR);
PropertyManager->Tie("velocities/q-rad_sec", this,2,
&FGRotation::GetPQR);
PropertyManager->Tie("velocities/r-rad_sec", this,3,
&FGRotation::GetPQR);
PropertyManager->Tie("velocities/p-aero-rad_sec", this,1,
&FGRotation::GetAeroPQR);
PropertyManager->Tie("velocities/q-aero-rad_sec", this,2,
&FGRotation::GetAeroPQR);
PropertyManager->Tie("velocities/r-aero-rad_sec", this,3,
&FGRotation::GetAeroPQR);
PropertyManager->Tie("accelerations/pdot-rad_sec", this,1,
&FGRotation::GetPQRdot);
PropertyManager->Tie("accelerations/qdot-rad_sec", this,2,
&FGRotation::GetPQRdot);
PropertyManager->Tie("accelerations/rdot-rad_sec", this,3,
&FGRotation::GetPQRdot);
PropertyManager->Tie("attitude/roll-rad", this,1,
&FGRotation::GetEuler);
PropertyManager->Tie("attitude/pitch-rad", this,2,
&FGRotation::GetEuler);
PropertyManager->Tie("attitude/heading-true-rad", this,3,
&FGRotation::GetEuler);
PropertyManager->Tie("velocities/phidot-rad_sec", this,1,
&FGRotation::GetEulerRates);
PropertyManager->Tie("velocities/thetadot-rad_sec", this,2,
&FGRotation::GetEulerRates);
PropertyManager->Tie("velocities/psidot-rad_sec", this,3,
&FGRotation::GetEulerRates);
PropertyManager->Tie("attitude/phi-rad", this,
&FGRotation::Getphi);
PropertyManager->Tie("attitude/theta-rad", this,
&FGRotation::Gettht);
PropertyManager->Tie("attitude/psi-true-rad", this,
&FGRotation::Getpsi);
}
void FGRotation::unbind(void){
PropertyManager->Untie("velocities/p-rad_sec");
PropertyManager->Untie("velocities/q-rad_sec");
PropertyManager->Untie("velocities/r-rad_sec");
PropertyManager->Untie("velocities/p-aero-rad_sec");
PropertyManager->Untie("velocities/q-aero-rad_sec");
PropertyManager->Untie("velocities/r-aero-rad_sec");
PropertyManager->Untie("accelerations/pdot-rad_sec");
PropertyManager->Untie("accelerations/qdot-rad_sec");
PropertyManager->Untie("accelerations/rdot-rad_sec");
PropertyManager->Untie("attitude/roll-rad");
PropertyManager->Untie("attitude/pitch-rad");
PropertyManager->Untie("attitude/heading-true-rad");
PropertyManager->Untie("velocities/phidot-rad_sec");
PropertyManager->Untie("velocities/thetadot-rad_sec");
PropertyManager->Untie("velocities/psidot-rad_sec");
PropertyManager->Untie("attitude/phi-rad");
PropertyManager->Untie("attitude/theta-rad");
PropertyManager->Untie("attitude/psi-true-rad");
}

32
src/FDM/JSBSim/FGRotation.h
View file

@ -87,32 +87,36 @@ public:
bool Run(void); bool Run(void);
inline FGColumnVector3& GetPQR(void) {return vPQR;} inline FGColumnVector3& GetPQR(void) {return vPQR;}
inline double GetPQR(int axis) {return vPQR(axis);} inline double GetPQR(int axis) const {return vPQR(axis);}
inline FGColumnVector3& GetAeroPQR(void) {return vAeroPQR;} inline FGColumnVector3& GetAeroPQR(void) {return vAeroPQR;}
inline double GetAeroPQR(int axis) {return vAeroPQR(axis);} inline double GetAeroPQR(int axis) const {return vAeroPQR(axis);}
inline FGColumnVector3& GetPQRdot(void) {return vPQRdot;} inline FGColumnVector3& GetPQRdot(void) {return vPQRdot;}
inline double GetPQRdot(int idx) {return vPQRdot(idx);} inline double GetPQRdot(int idx) const {return vPQRdot(idx);}
inline FGColumnVector3& GetEuler(void) {return vEuler;} inline FGColumnVector3& GetEuler(void) {return vEuler;}
inline double GetEuler(int axis) {return vEuler(axis);} inline double GetEuler(int axis) const {return vEuler(axis);}
inline FGColumnVector3& GetEulerRates(void) { return vEulerRates; } inline FGColumnVector3& GetEulerRates(void) { return vEulerRates; }
inline double GetEulerRates(int axis) { return vEulerRates(axis); } inline double GetEulerRates(int axis) const { return vEulerRates(axis); }
inline void SetPQR(FGColumnVector3 tt) {vPQR = tt;} inline void SetPQR(FGColumnVector3 tt) {vPQR = tt;}
inline void SetPQR(double p, double q, double r) {vPQR(eP)=p; inline void SetPQR(double p, double q, double r) {vPQR(eP)=p;
vPQR(eQ)=q; vPQR(eQ)=q;
vPQR(eR)=r;} vPQR(eR)=r;}
inline void SetEuler(FGColumnVector3 tt) {vEuler = tt;} inline void SetEuler(FGColumnVector3 tt) {vEuler = tt;}
inline double Getphi(void) {return vEuler(1);} inline double Getphi(void) const {return vEuler(1);}
inline double Gettht(void) {return vEuler(2);} inline double Gettht(void) const {return vEuler(2);}
inline double Getpsi(void) {return vEuler(3);} inline double Getpsi(void) const {return vEuler(3);}
inline double GetCosphi(void) {return cPhi;} inline double GetCosphi(void) const {return cPhi;}
inline double GetCostht(void) {return cTht;} inline double GetCostht(void) const {return cTht;}
inline double GetCospsi(void) {return cPsi;} inline double GetCospsi(void) const {return cPsi;}
inline double GetSinphi(void) const {return sPhi;}
inline double GetSintht(void) const {return sTht;}
inline double GetSinpsi(void) const {return sPsi;}
void bind(void);
void unbind(void);
inline double GetSinphi(void) {return sPhi;}
inline double GetSintht(void) {return sTht;}
inline double GetSinpsi(void) {return sPsi;}
private: private:
FGColumnVector3 vPQR; FGColumnVector3 vPQR;

231
src/FDM/JSBSim/FGState.cpp
View file

@ -47,7 +47,8 @@ INCLUDES
# endif # endif
#endif #endif
#ifdef _MSC_VER #if defined(_MSC_VER)||defined(__BORLANDCPP__)
#pragma message("\n\nRedefining snprintf\n")
#define snprintf _snprintf #define snprintf _snprintf
#endif #endif
@ -92,6 +93,9 @@ FGState::FGState(FGFDMExec* fdex)
Aerodynamics = FDMExec->GetAerodynamics(); Aerodynamics = FDMExec->GetAerodynamics();
GroundReactions = FDMExec->GetGroundReactions(); GroundReactions = FDMExec->GetGroundReactions();
Propulsion = FDMExec->GetPropulsion(); Propulsion = FDMExec->GetPropulsion();
PropertyManager = FDMExec->GetPropertyManager();
InitPropertyMaps();
RegisterVariable(FG_TIME, " time " ); RegisterVariable(FG_TIME, " time " );
RegisterVariable(FG_QBAR, " qbar " ); RegisterVariable(FG_QBAR, " qbar " );
@ -170,6 +174,8 @@ FGState::FGState(FGFDMExec* fdex)
RegisterVariable(FG_VBARV, " v-tail volume " ); RegisterVariable(FG_VBARV, " v-tail volume " );
RegisterVariable(FG_SET_LOGGING, " data_logging " ); RegisterVariable(FG_SET_LOGGING, " data_logging " );
bind();
Debug(0); Debug(0);
} }
@ -177,6 +183,7 @@ FGState::FGState(FGFDMExec* fdex)
FGState::~FGState() FGState::~FGState()
{ {
unbind();
Debug(1); Debug(1);
} }
@ -249,43 +256,43 @@ double FGState::GetParameter(eParam val_idx) {
case FG_AELEVATOR_POS: case FG_AELEVATOR_POS:
return fabs(FCS->GetDePos()); return fabs(FCS->GetDePos());
case FG_NELEVATOR_POS: case FG_NELEVATOR_POS:
return FCS->GetDePosN(); return FCS->GetDePos(ofNorm);
case FG_AILERON_POS: case FG_AILERON_POS:
return FCS->GetDaLPos(); return FCS->GetDaLPos();
case FG_AAILERON_POS: case FG_AAILERON_POS:
return fabs(FCS->GetDaLPos()); return fabs(FCS->GetDaLPos());
case FG_NAILERON_POS: case FG_NAILERON_POS:
return FCS->GetDaLPosN(); return FCS->GetDaLPos(ofNorm);
case FG_LEFT_AILERON_POS: case FG_LEFT_AILERON_POS:
return FCS->GetDaLPos(); return FCS->GetDaLPos();
case FG_ALEFT_AILERON_POS: case FG_ALEFT_AILERON_POS:
return fabs(FCS->GetDaLPos()); return FCS->GetDaLPos(ofMag);
case FG_NLEFT_AILERON_POS: case FG_NLEFT_AILERON_POS:
return FCS->GetDaLPosN(); return FCS->GetDaLPos(ofNorm);
case FG_RIGHT_AILERON_POS: case FG_RIGHT_AILERON_POS:
return FCS->GetDaRPos(); return FCS->GetDaRPos();
case FG_ARIGHT_AILERON_POS: case FG_ARIGHT_AILERON_POS:
return fabs(FCS->GetDaRPos()); return FCS->GetDaRPos(ofMag);
case FG_NRIGHT_AILERON_POS: case FG_NRIGHT_AILERON_POS:
return FCS->GetDaRPosN(); return FCS->GetDaRPos(ofNorm);
case FG_RUDDER_POS: case FG_RUDDER_POS:
return FCS->GetDrPos(); return FCS->GetDrPos();
case FG_ARUDDER_POS: case FG_ARUDDER_POS:
return fabs(FCS->GetDrPos()); return FCS->GetDrPos(ofMag);
case FG_NRUDDER_POS: case FG_NRUDDER_POS:
return FCS->GetDrPosN(); return FCS->GetDrPos(ofNorm);
case FG_SPDBRAKE_POS: case FG_SPDBRAKE_POS:
return FCS->GetDsbPos(); return FCS->GetDsbPos();
case FG_NSPDBRAKE_POS: case FG_NSPDBRAKE_POS:
return FCS->GetDsbPosN(); return FCS->GetDsbPos(ofNorm);
case FG_SPOILERS_POS: case FG_SPOILERS_POS:
return FCS->GetDspPos(); return FCS->GetDspPos();
case FG_NSPOILERS_POS: case FG_NSPOILERS_POS:
return FCS->GetDspPosN(); return FCS->GetDspPos(ofNorm);
case FG_FLAPS_POS: case FG_FLAPS_POS:
return FCS->GetDfPos(); return FCS->GetDfPos();
case FG_NFLAPS_POS: case FG_NFLAPS_POS:
return FCS->GetDfPosN(); return FCS->GetDfPos(ofNorm);
case FG_ELEVATOR_CMD: case FG_ELEVATOR_CMD:
return FCS->GetDeCmd(); return FCS->GetDeCmd();
case FG_AILERON_CMD: case FG_AILERON_CMD:
@ -375,52 +382,52 @@ void FGState::SetParameter(eParam val_idx, double val)
switch(val_idx) { switch(val_idx) {
case FG_ELEVATOR_POS: case FG_ELEVATOR_POS:
FCS->SetDePos(val); FCS->SetDePos(ofRad,val);
break; break;
case FG_NELEVATOR_POS: case FG_NELEVATOR_POS:
FCS->SetDePosN(val); FCS->SetDePos(ofNorm,val);
break; break;
case FG_AILERON_POS: case FG_AILERON_POS:
FCS->SetDaLPos(val); FCS->SetDaLPos(ofRad,val);
break; break;
case FG_NAILERON_POS: case FG_NAILERON_POS:
FCS->SetDaLPosN(val); FCS->SetDaLPos(ofNorm,val);
break; break;
case FG_LEFT_AILERON_POS: case FG_LEFT_AILERON_POS:
FCS->SetDaLPos(val); FCS->SetDaLPos(ofRad,val);
break; break;
case FG_NLEFT_AILERON_POS: case FG_NLEFT_AILERON_POS:
FCS->SetDaLPosN(val); FCS->SetDaLPos(ofNorm,val);
break; break;
case FG_RIGHT_AILERON_POS: case FG_RIGHT_AILERON_POS:
FCS->SetDaRPos(val); FCS->SetDaRPos(ofRad,val);
break; break;
case FG_NRIGHT_AILERON_POS: case FG_NRIGHT_AILERON_POS:
FCS->SetDaRPosN(val); FCS->SetDaRPos(ofNorm,val);
break; break;
case FG_RUDDER_POS: case FG_RUDDER_POS:
FCS->SetDrPos(val); FCS->SetDrPos(ofRad,val);
break; break;
case FG_NRUDDER_POS: case FG_NRUDDER_POS:
FCS->SetDrPosN(val); FCS->SetDrPos(ofNorm,val);
break; break;
case FG_SPDBRAKE_POS: case FG_SPDBRAKE_POS:
FCS->SetDsbPos(val); FCS->SetDsbPos(ofRad,val);
break; break;
case FG_NSPDBRAKE_POS: case FG_NSPDBRAKE_POS:
FCS->SetDsbPosN(val); FCS->SetDsbPos(ofNorm,val);
break; break;
case FG_SPOILERS_POS: case FG_SPOILERS_POS:
FCS->SetDspPos(val); FCS->SetDspPos(ofRad,val);
break; break;
case FG_NSPOILERS_POS: case FG_NSPOILERS_POS:
FCS->SetDspPosN(val); FCS->SetDspPos(ofNorm,val);
break; break;
case FG_FLAPS_POS: case FG_FLAPS_POS:
FCS->SetDfPos(val); FCS->SetDfPos(ofRad,val);
break; break;
case FG_NFLAPS_POS: case FG_NFLAPS_POS:
FCS->SetDfPosN(val); FCS->SetDfPos(ofNorm,val);
break; break;
case FG_THROTTLE_POS: case FG_THROTTLE_POS:
if (ActiveEngine == -1) { if (ActiveEngine == -1) {
@ -856,7 +863,9 @@ FGMatrix33& FGState::GetTb2s(void)
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
void FGState::ReportState(void) { void FGState::ReportState(void)
{
#if !defined(__BORLANDCPP__)
char out[80], flap[10], gear[12]; char out[80], flap[10], gear[12];
cout << endl << " JSBSim State" << endl; cout << endl << " JSBSim State" << endl;
@ -925,8 +934,172 @@ void FGState::ReportState(void) {
Position->GetVground()*fpstokts, Position->GetVground()*fpstokts,
Position->GetGroundTrack()*radtodeg ); Position->GetGroundTrack()*radtodeg );
cout << out; cout << out;
#endif
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
void FGState::InitPropertyMaps(void) {
ParamToProp[ FG_TIME ]="sim-time-sec";
ParamToProp[ FG_QBAR ]="aero/qbar-psf";
ParamToProp[ FG_WINGAREA ]="metrics/Sw-sqft";
ParamToProp[ FG_WINGSPAN ]="metrics/bw-ft";
ParamToProp[ FG_CBAR ]="metrics/cbarw-ft";
ParamToProp[ FG_ALPHA ]="aero/alpha-rad";
ParamToProp[ FG_ALPHADOT ]="aero/alphadot-rad_sec";
ParamToProp[ FG_BETA ]="aero/beta-rad";
ParamToProp[ FG_ABETA ]="aero/mag-beta-rad";
ParamToProp[ FG_BETADOT ]="aero/betadot-rad_sec";
ParamToProp[ FG_PHI ]="attitude/phi-rad";
ParamToProp[ FG_THT ]="attitude/theta-rad";
ParamToProp[ FG_PSI ]="attitude/psi-true-rad";
ParamToProp[ FG_PITCHRATE ]="velocities/q-rad_sec";
ParamToProp[ FG_ROLLRATE ]="velocities/p-rad_sec";
ParamToProp[ FG_YAWRATE ]="velocities/r-rad_sec";
ParamToProp[ FG_AEROP ]="velocities/p-aero-rad_sec";
ParamToProp[ FG_AEROQ ]="velocities/q-aero-rad_sec";
ParamToProp[ FG_AEROR ]="velocities/r-aero-rad_sec";
ParamToProp[ FG_CL_SQRD ]="aero/cl-squared-norm";
ParamToProp[ FG_MACH ]="velocities/mach-norm";
ParamToProp[ FG_ALTITUDE ]="position/h-sl-ft";
ParamToProp[ FG_BI2VEL ]="aero/bi2vel";
ParamToProp[ FG_CI2VEL ]="aero/ci2vel";
ParamToProp[ FG_ELEVATOR_POS ]="fcs/elevator-pos-rad";
ParamToProp[ FG_AELEVATOR_POS ]="fcs/mag-elevator-pos-rad";
ParamToProp[ FG_NELEVATOR_POS ]="fcs/elevator-pos-norm";
ParamToProp[ FG_AILERON_POS ]="fcs/left-aileron-pos-rad";
ParamToProp[ FG_AAILERON_POS ]="fcs/mag-aileron-pos-rad";
ParamToProp[ FG_NAILERON_POS ]="fcs/left-aileron-pos-norm";
ParamToProp[ FG_LEFT_AILERON_POS ]="fcs/left-aileron-pos-rad";
ParamToProp[ FG_ALEFT_AILERON_POS ]="fcs/mag-left-aileron-pos-rad";
ParamToProp[ FG_NLEFT_AILERON_POS ]="fcs/left-aileron-pos-norm";
ParamToProp[ FG_RIGHT_AILERON_POS ]="fcs/right-aileron-pos-rad";
ParamToProp[ FG_ARIGHT_AILERON_POS ]="fcs/mag-aileron-pos-rad";
ParamToProp[ FG_NRIGHT_AILERON_POS ]="fcs/right-aileron-pos-norm";
ParamToProp[ FG_RUDDER_POS ]="fcs/rudder-pos-rad";
ParamToProp[ FG_ARUDDER_POS ]="fcs/mag-rudder-pos-rad";
ParamToProp[ FG_NRUDDER_POS ]="fcs/rudder-pos-norm";
ParamToProp[ FG_SPDBRAKE_POS ]="fcs/speedbrake-pos-rad";
ParamToProp[ FG_NSPDBRAKE_POS ]="fcs/speedbrake-pos-norm";
ParamToProp[ FG_SPOILERS_POS ]="fcs/spoiler-pos-rad";
ParamToProp[ FG_NSPOILERS_POS ]="fcs/spoiler-pos-norm";
ParamToProp[ FG_FLAPS_POS ]="fcs/flap-pos-deg";
ParamToProp[ FG_NFLAPS_POS ]="fcs/flap-pos-norm";
ParamToProp[ FG_ELEVATOR_CMD ]="fcs/elevator-cmd-norm";
ParamToProp[ FG_AILERON_CMD ]="fcs/aileron-cmd-norm";
ParamToProp[ FG_RUDDER_CMD ]="fcs/rudder-cmd-norm";
ParamToProp[ FG_SPDBRAKE_CMD ]="fcs/speedbrake-cmd-norm";
ParamToProp[ FG_SPOILERS_CMD ]="fcs/spoiler-cmd-norm";
ParamToProp[ FG_FLAPS_CMD ]="fcs/flap-cmd-norm";
ParamToProp[ FG_THROTTLE_CMD ]="zero";
ParamToProp[ FG_THROTTLE_POS ]="zero";
ParamToProp[ FG_MIXTURE_CMD ]="zero";
ParamToProp[ FG_MIXTURE_POS ]="zero";
ParamToProp[ FG_MAGNETO_CMD ]="zero";
ParamToProp[ FG_STARTER_CMD ]="zero";
ParamToProp[ FG_ACTIVE_ENGINE ]="zero";
ParamToProp[ FG_HOVERB ]="position/h_b-mac-ft";
ParamToProp[ FG_PITCH_TRIM_CMD ]="fcs/pitch-trim-cmd-norm";
ParamToProp[ FG_YAW_TRIM_CMD ]="fcs/yaw-trim-cmd-norm";
ParamToProp[ FG_ROLL_TRIM_CMD ]="fcs/roll-trim-cmd-norm";
ParamToProp[ FG_LEFT_BRAKE_CMD ]="zero";
ParamToProp[ FG_CENTER_BRAKE_CMD ]="zero";
ParamToProp[ FG_RIGHT_BRAKE_CMD ]="zero";
ParamToProp[ FG_SET_LOGGING ]="zero";
ParamToProp[ FG_ALPHAH ]="aero/alpha-rad";
ParamToProp[ FG_ALPHAW ]="aero/alpha-wing-rad";
ParamToProp[ FG_LBARH ]="metrics/lh-norm";
ParamToProp[ FG_LBARV ]="metrics/lv-norm";
ParamToProp[ FG_HTAILAREA ]="metrics/Sh-sqft";
ParamToProp[ FG_VTAILAREA ]="metrics/Sv-sqft";
ParamToProp[ FG_VBARH ]="metrics/vbarh-norm";
ParamToProp[ FG_VBARV ]="metrics/vbarv-norm";
ParamToProp[ FG_GEAR_CMD ]="gear/gear-cmd-norm";
ParamToProp[ FG_GEAR_POS ]="gear/gear-pos-norm";
PropToParam[ "sim-time-sec" ] = FG_TIME;
PropToParam[ "aero/qbar-psf" ] = FG_QBAR;
PropToParam[ "metrics/Sw-sqft" ] = FG_WINGAREA;
PropToParam[ "metrics/bw-ft" ] = FG_WINGSPAN;
PropToParam[ "metrics/cbarw-ft" ] = FG_CBAR;
PropToParam[ "aero/alpha-rad" ] = FG_ALPHA;
PropToParam[ "aero/alphadot-rad_sec" ] = FG_ALPHADOT;
PropToParam[ "aero/beta-rad" ] = FG_BETA;
PropToParam[ "aero/mag-beta-rad" ] = FG_ABETA;
PropToParam[ "aero/betadot-rad_sec" ] = FG_BETADOT;
PropToParam[ "attitude/phi-rad" ] = FG_PHI;
PropToParam[ "attitude/theta-rad" ] = FG_THT;
PropToParam[ "attitude/psi-true-rad" ] = FG_PSI;
PropToParam[ "velocities/q-rad_sec" ] = FG_PITCHRATE;
PropToParam[ "velocities/p-rad_sec" ] = FG_ROLLRATE;
PropToParam[ "velocities/r-rad_sec" ] = FG_YAWRATE;
PropToParam[ "velocities/p-aero-rad_sec" ] = FG_AEROP;
PropToParam[ "velocities/q-aero-rad_sec" ] = FG_AEROQ;
PropToParam[ "velocities/r-aero-rad_sec" ] = FG_AEROR;
PropToParam[ "aero/cl-squared-norm" ] = FG_CL_SQRD;
PropToParam[ "velocities/mach-norm" ] = FG_MACH;
PropToParam[ "position/h-sl-ft" ] = FG_ALTITUDE;
PropToParam[ "aero/bi2vel" ] = FG_BI2VEL;
PropToParam[ "aero/ci2vel" ] = FG_CI2VEL;
PropToParam[ "fcs/elevator-pos-rad" ] = FG_ELEVATOR_POS;
PropToParam[ "fcs/mag-elevator-pos-rad" ] = FG_AELEVATOR_POS;
PropToParam[ "fcs/elevator-pos-norm" ] = FG_NELEVATOR_POS;
PropToParam[ "fcs/left-aileron-pos-rad" ] = FG_AILERON_POS;
PropToParam[ "fcs/mag-aileron-pos-rad" ] = FG_AAILERON_POS;
PropToParam[ "fcs/left-aileron-pos-norm" ] = FG_NAILERON_POS;
PropToParam[ "fcs/left-aileron-pos-rad" ] = FG_LEFT_AILERON_POS;
PropToParam[ "fcs/mag-left-aileron-pos-rad" ] = FG_ALEFT_AILERON_POS;
PropToParam[ "fcs/left-aileron-pos-norm" ] = FG_NLEFT_AILERON_POS;
PropToParam[ "fcs/right-aileron-pos-rad" ] = FG_RIGHT_AILERON_POS;
PropToParam[ "fcs/mag-aileron-pos-rad" ] = FG_ARIGHT_AILERON_POS;
PropToParam[ "fcs/right-aileron-pos-norm" ] = FG_NRIGHT_AILERON_POS;
PropToParam[ "fcs/rudder-pos-rad" ] = FG_RUDDER_POS;
PropToParam[ "fcs/mag-rudder-pos-rad" ] = FG_ARUDDER_POS;
PropToParam[ "fcs/rudder-pos-norm" ] = FG_NRUDDER_POS;
PropToParam[ "fcs/speedbrake-pos-rad" ] = FG_SPDBRAKE_POS;
PropToParam[ "fcs/speedbrake-pos-norm" ] = FG_NSPDBRAKE_POS;
PropToParam[ "fcs/spoiler-pos-rad" ] = FG_SPOILERS_POS;
PropToParam[ "fcs/spoiler-pos-norm" ] = FG_NSPOILERS_POS;
PropToParam[ "fcs/flap-pos-deg" ] = FG_FLAPS_POS;
PropToParam[ "fcs/flap-pos-norm" ] = FG_NFLAPS_POS;
PropToParam[ "fcs/elevator-cmd-norm" ] = FG_ELEVATOR_CMD;
PropToParam[ "fcs/aileron-cmd-norm" ] = FG_AILERON_CMD;
PropToParam[ "fcs/rudder-cmd-norm" ] = FG_RUDDER_CMD;
PropToParam[ "fcs/speedbrake-cmd-norm" ] = FG_SPDBRAKE_CMD;
PropToParam[ "fcs/spoiler-cmd-norm" ] = FG_SPOILERS_CMD;
PropToParam[ "fcs/flap-cmd-norm" ] = FG_FLAPS_CMD;
PropToParam[ "position/h_b-mac-ft" ] = FG_HOVERB;
PropToParam[ "fcs/pitch-trim-cmd-norm" ] = FG_PITCH_TRIM_CMD;
PropToParam[ "fcs/yaw-trim-cmd-norm" ] = FG_YAW_TRIM_CMD;
PropToParam[ "fcs/roll-trim-cmd-norm" ] = FG_ROLL_TRIM_CMD;
PropToParam[ "aero/alpha-rad" ] = FG_ALPHAH;
PropToParam[ "aero/alpha-wing-rad" ] = FG_ALPHAW;
PropToParam[ "metrics/lh-norm" ] = FG_LBARH;
PropToParam[ "metrics/lv-norm" ] = FG_LBARV;
PropToParam[ "metrics/Sh-sqft" ] = FG_HTAILAREA;
PropToParam[ "metrics/Sv-sqft" ] = FG_VTAILAREA;
PropToParam[ "metrics/vbarh-norm" ] = FG_VBARH;
PropToParam[ "metrics/vbarv-norm" ] = FG_VBARV;
PropToParam[ "gear/gear-cmd-norm" ] = FG_GEAR_CMD;
PropToParam[ "gear/gear-pos-norm" ] = FG_GEAR_POS;
} }
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
void FGState::bind(void) {
PropertyManager->Tie("sim-time-sec",this,
&FGState::Getsim_time);
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
void FGState::unbind(void) {
PropertyManager->Untie("sim-time-sec");
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// The bitmasked value choices are as follows: // The bitmasked value choices are as follows:
// unset: In this case (the default) JSBSim would only print // unset: In this case (the default) JSBSim would only print

15
src/FDM/JSBSim/FGState.h
View file

@ -176,7 +176,7 @@ public:
inline double Geta(void) { return a; } inline double Geta(void) { return a; }
/// Returns the simulation time in seconds. /// Returns the simulation time in seconds.
inline double Getsim_time(void) { return sim_time; } inline double Getsim_time(void) const { return sim_time; }
/// Returns the simulation delta T. /// Returns the simulation delta T.
inline double Getdt(void) { return dt; } inline double Getdt(void) { return dt; }
@ -309,6 +309,12 @@ public:
*/ */
void ReportState(void); void ReportState(void);
inline string GetPropertyName(eParam prm) { return ParamToProp[prm]; }
inline eParam GetParam(string property) { return PropToParam[property]; }
void bind();
void unbind();
private: private:
double a; // speed of sound double a; // speed of sound
double sim_time, dt; double sim_time, dt;
@ -339,6 +345,7 @@ private:
FGAerodynamics* Aerodynamics; FGAerodynamics* Aerodynamics;
FGGroundReactions* GroundReactions; FGGroundReactions* GroundReactions;
FGPropulsion* Propulsion; FGPropulsion* Propulsion;
FGPropertyManager* PropertyManager;
typedef map<string, eParam> CoeffMap; typedef map<string, eParam> CoeffMap;
CoeffMap coeffdef; CoeffMap coeffdef;
@ -346,7 +353,13 @@ private:
typedef map<eParam, string> ParamMap; typedef map<eParam, string> ParamMap;
ParamMap paramdef; ParamMap paramdef;
ParamMap ParamToProp;
CoeffMap PropToParam;
int ActiveEngine; int ActiveEngine;
void InitPropertyMaps(void);
void Debug(int from); void Debug(int from);
}; };

83
src/FDM/JSBSim/FGTranslation.cpp
View file

@ -68,6 +68,7 @@ INCLUDES
#include "FGPosition.h" #include "FGPosition.h"
#include "FGAuxiliary.h" #include "FGAuxiliary.h"
#include "FGOutput.h" #include "FGOutput.h"
#include "FGPropertyManager.h"
static const char *IdSrc = "$Id$"; static const char *IdSrc = "$Id$";
static const char *IdHdr = ID_TRANSLATION; static const char *IdHdr = ID_TRANSLATION;
@ -85,7 +86,7 @@ FGTranslation::FGTranslation(FGFDMExec* fdmex) : FGModel(fdmex)
Mach = 0.0; Mach = 0.0;
alpha = beta = 0.0; alpha = beta = 0.0;
adot = bdot = 0.0; adot = bdot = 0.0;
bind();
Debug(0); Debug(0);
} }
@ -93,6 +94,7 @@ FGTranslation::FGTranslation(FGFDMExec* fdmex) : FGModel(fdmex)
FGTranslation::~FGTranslation(void) FGTranslation::~FGTranslation(void)
{ {
unbind();
Debug(1); Debug(1);
} }
@ -221,3 +223,82 @@ void FGTranslation::Debug(int from)
} }
} }
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
void FGTranslation::bind(void){
PropertyManager->Tie("velocities/u-fps", this,1,
&FGTranslation::GetUVW /*,
&FGTranslation::SetUVW,
true */);
PropertyManager->Tie("velocities/v-fps", this,2,
&FGTranslation::GetUVW /*,
&FGTranslation::SetUVW,
true*/);
PropertyManager->Tie("velocities/w-fps", this,3,
&FGTranslation::GetUVW /*,
&FGTranslation::SetUVW,
true*/);
PropertyManager->Tie("accelerations/udot-fps", this,1,
&FGTranslation::GetUVWdot);
PropertyManager->Tie("accelerations/vdot-fps", this,2,
&FGTranslation::GetUVWdot);
PropertyManager->Tie("accelerations/wdot-fps", this,3,
&FGTranslation::GetUVWdot);
PropertyManager->Tie("velocities/u-aero-fps", this,1,
&FGTranslation::GetvAeroUVW);
PropertyManager->Tie("velocities/v-aero-fps", this,2,
&FGTranslation::GetvAeroUVW);
PropertyManager->Tie("velocities/w-aero-fps", this,3,
&FGTranslation::GetvAeroUVW);
PropertyManager->Tie("aero/alpha-rad", this,
&FGTranslation::Getalpha,
&FGTranslation::Setalpha,
true);
PropertyManager->Tie("aero/beta-rad", this,
&FGTranslation::Getbeta,
&FGTranslation::Setbeta,
true);
PropertyManager->Tie("aero/mag-beta-rad", this,
&FGTranslation::GetMagBeta);
PropertyManager->Tie("aero/qbar-psf", this,
&FGTranslation::Getqbar,
&FGTranslation::Setqbar,
true);
PropertyManager->Tie("velocities/vt-fps", this,
&FGTranslation::GetVt,
&FGTranslation::SetVt,
true);
PropertyManager->Tie("velocities/mach-norm", this,
&FGTranslation::GetMach,
&FGTranslation::SetMach,
true);
PropertyManager->Tie("aero/alphadot-rad_sec", this,
&FGTranslation::Getadot,
&FGTranslation::Setadot,
true);
PropertyManager->Tie("aero/betadot-rad_sec", this,
&FGTranslation::Getbdot,
&FGTranslation::Setbdot,
true);
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
void FGTranslation::unbind(void){
PropertyManager->Untie("velocities/u-fps");
PropertyManager->Untie("velocities/v-fps");
PropertyManager->Untie("velocities/w-fps");
PropertyManager->Untie("accelerations/udot-fps");
PropertyManager->Untie("accelerations/vdot-fps");
PropertyManager->Untie("accelerations/wdot-fps");
PropertyManager->Untie("velocities/u-aero-fps");
PropertyManager->Untie("velocities/v-aero-fps");
PropertyManager->Untie("velocities/w-aero-fps");
PropertyManager->Untie("aero/alpha-rad");
PropertyManager->Untie("aero/beta-rad");
PropertyManager->Untie("aero/qbar-psf");
PropertyManager->Untie("velocities/vt-fps");
PropertyManager->Untie("velocities/mach-norm");
PropertyManager->Untie("aero/alphadot-rad_sec");
PropertyManager->Untie("aero/betadot-rad_sec");
}

24
src/FDM/JSBSim/FGTranslation.h
View file

@ -87,20 +87,21 @@ public:
FGTranslation(FGFDMExec*); FGTranslation(FGFDMExec*);
~FGTranslation(); ~FGTranslation();
inline double GetUVW (int idx) const { return vUVW(idx); }
inline FGColumnVector3& GetUVW (void) { return vUVW; } inline FGColumnVector3& GetUVW (void) { return vUVW; }
inline double GetUVW (int idx) { return vUVW(idx); }
inline FGColumnVector3& GetUVWdot(void) { return vUVWdot; } inline FGColumnVector3& GetUVWdot(void) { return vUVWdot; }
inline double GetUVWdot(int idx) { return vUVWdot(idx); } inline double GetUVWdot(int idx) const { return vUVWdot(idx); }
inline FGColumnVector3& GetvAeroUVW (void) { return vAeroUVW; } inline FGColumnVector3& GetvAeroUVW (void) { return vAeroUVW; }
inline double GetvAeroUVW (int idx) { return vAeroUVW(idx); } inline double GetvAeroUVW (int idx) const { return vAeroUVW(idx); }
inline double Getalpha(void) { return alpha; } double Getalpha(void) const { return alpha; }
inline double Getbeta (void) { return beta; } double Getbeta (void) const { return beta; }
inline double Getqbar (void) { return qbar; } inline double GetMagBeta(void) const { return fabs(beta); }
inline double GetVt (void) { return Vt; } double Getqbar (void) const { return qbar; }
inline double GetMach (void) { return Mach; } inline double GetVt (void) const { return Vt; }
inline double Getadot (void) { return adot; } double GetMach (void) const { return Mach; }
inline double Getbdot (void) { return bdot; } double Getadot (void) const { return adot; }
double Getbdot (void) const { return bdot; }
void SetUVW(FGColumnVector3 tt) { vUVW = tt; } void SetUVW(FGColumnVector3 tt) { vUVW = tt; }
@ -116,6 +117,9 @@ public:
bool Run(void); bool Run(void);
void bind(void);
void unbind(void);
private: private:
FGColumnVector3 vUVW; FGColumnVector3 vUVW;
FGColumnVector3 vUVWdot; FGColumnVector3 vUVWdot;

9
src/FDM/JSBSim/FGTrim.cpp
View file

@ -614,6 +614,7 @@ void FGTrim::setupTurn(void){
} }
void FGTrim::updateRates(void){ void FGTrim::updateRates(void){
if( mode == tTurn ) {
double phi = fgic->GetRollAngleRadIC(); double phi = fgic->GetRollAngleRadIC();
double g = fdmex->GetInertial()->gravity(); double g = fdmex->GetInertial()->gravity();
if(fabs(phi) > 0.001 && fabs(phi) < 1.56 ) { if(fabs(phi) > 0.001 && fabs(phi) < 1.56 ) {
@ -626,6 +627,14 @@ void FGTrim::updateRates(void){
r=psidot*cos(theta)*cos(phi); r=psidot*cos(theta)*cos(phi);
fdmex->GetRotation()->SetPQR(p,q,r); fdmex->GetRotation()->SetPQR(p,q,r);
} }
} else if( mode == tPullup && fabs(targetNlf-1) > 0.01) {
float g,q,cgamma;
FGColumnVector3 vPQR;
g=fdmex->GetInertial()->gravity();
cgamma=cos(fgic->GetFlightPathAngleRadIC());
q=g*(targetNlf-cgamma)/fgic->GetVtrueFpsIC();
fdmex->GetRotation()->SetPQR(0,q,0);
}
} }
void FGTrim::setDebug(void) { void FGTrim::setDebug(void) {

16
src/FDM/JSBSim/FGTrim.h
View file

@ -32,10 +32,12 @@
FUNCTIONAL DESCRIPTION FUNCTIONAL DESCRIPTION
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
This class takes the given set of IC's and finds the angle of attack, elevator, This class takes the given set of IC's and finds the aircraft state required to
and throttle setting required to fly steady level. This is currently for in-air maintain a specified flight condition. This flight condition can be
conditions only. It is implemented using an iterative, one-axis-at-a-time steady-level with non-zero sideslip, a steady turn, a pull-up or pushover.
scheme. On-ground conditions can be trimmed as well, but this is currently limited to
adjusting altitude and pitch angle only. It is implemented using an iterative,
one-axis-at-a-time scheme.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SENTRY SENTRY
@ -107,12 +109,14 @@ CLASS DOCUMENTATION
<li> tLongitudinal: Trim wdot with alpha, udot with thrust, qdot with elevator</li> <li> tLongitudinal: Trim wdot with alpha, udot with thrust, qdot with elevator</li>
<li> tFull: tLongitudinal + vdot with phi, pdot with aileron, rdot with rudder <li> tFull: tLongitudinal + vdot with phi, pdot with aileron, rdot with rudder
and heading minus ground track (hmgt) with beta</li> and heading minus ground track (hmgt) with beta</li>
<li> tPullup: tLongitudinal but adjust alpha to achieve load factor input
with SetTargetNlf()
<li> tGround: wdot with altitude, qdot with theta, and pdot with phi</li> <li> tGround: wdot with altitude, qdot with theta, and pdot with phi</li>
The remaining modes include <b>tCustom</b>, which is completely user defined and The remaining modes include <b>tCustom</b>, which is completely user defined and
<b>tNone</b>. <b>tNone</b>.
</ul> </ul>
Currently, this class cannot trim a non-1g condition and is limited to
trimming for constant true airspeed in climbs and descents.
Note that trims can (and do) fail for reasons that are completely outside Note that trims can (and do) fail for reasons that are completely outside
the control of the trimming routine itself. The most common problem is the the control of the trimming routine itself. The most common problem is the

27
src/FDM/JSBSim/JSBSim.cxx
View file

@ -55,6 +55,7 @@
#include <FDM/JSBSim/FGMassBalance.h> #include <FDM/JSBSim/FGMassBalance.h>
#include <FDM/JSBSim/FGAerodynamics.h> #include <FDM/JSBSim/FGAerodynamics.h>
#include <FDM/JSBSim/FGLGear.h> #include <FDM/JSBSim/FGLGear.h>
#include <FDM/JSBSim/FGPropertyManager.h>
#include "JSBSim.hxx" #include "JSBSim.hxx"
/******************************************************************************/ /******************************************************************************/
@ -64,7 +65,7 @@ FGJSBsim::FGJSBsim( double dt )
{ {
bool result; bool result;
fdmex = new FGFDMExec; fdmex = new FGFDMExec( (FGPropertyManager*)globals->get_props() );
State = fdmex->GetState(); State = fdmex->GetState();
Atmosphere = fdmex->GetAtmosphere(); Atmosphere = fdmex->GetAtmosphere();
@ -151,14 +152,6 @@ FGJSBsim::FGJSBsim( double dt )
stall_warning = fgGetNode("/sim/aero/alarms/stall-warning",true); stall_warning = fgGetNode("/sim/aero/alarms/stall-warning",true);
stall_warning->setDoubleValue(0); stall_warning->setDoubleValue(0);
/* elevator_pos_deg=fgGetNode("/surface-positions/elevator-pos-deg",true);
left_aileron_pos_deg
=fgGetNode("/surface-positions/left-aileron-pos-deg",true);
right_aileron_pos_deg
=fgGetNode("/surface-positions/right-aileron-pos-deg",true);
rudder_pos_deg=fgGetNode("/surface-positions/rudder-pos-deg",true);
flap_pos_deg=fgGetNode("/surface-positions/flap-pos-deg",true); */
flap_pos_pct=fgGetNode("/surface-positions/flap-pos-norm",true); flap_pos_pct=fgGetNode("/surface-positions/flap-pos-norm",true);
elevator_pos_pct=fgGetNode("/surface-positions/elevator-pos-norm",true); elevator_pos_pct=fgGetNode("/surface-positions/elevator-pos-norm",true);
@ -169,12 +162,6 @@ FGJSBsim::FGJSBsim( double dt )
rudder_pos_pct=fgGetNode("/surface-positions/rudder-pos-norm",true); rudder_pos_pct=fgGetNode("/surface-positions/rudder-pos-norm",true);
/* elevator_pos_deg->setDoubleValue(0);
left_aileron_pos_deg->setDoubleValue(0);
right_aileron_pos_deg->setDoubleValue(0);
rudder_pos_deg->setDoubleValue(0);
flap_pos_deg->setDoubleValue(0); */
elevator_pos_pct->setDoubleValue(0); elevator_pos_pct->setDoubleValue(0);
left_aileron_pos_pct->setDoubleValue(0); left_aileron_pos_pct->setDoubleValue(0);
@ -527,11 +514,11 @@ bool FGJSBsim::copy_from_JSBsim() {
flap_pos_deg->setDoubleValue( FCS->GetDfPos() ); */ flap_pos_deg->setDoubleValue( FCS->GetDfPos() ); */
elevator_pos_pct->setDoubleValue( FCS->GetDePosN() ); elevator_pos_pct->setDoubleValue( FCS->GetDePos(ofNorm) );
left_aileron_pos_pct->setDoubleValue( FCS->GetDaLPosN() ); left_aileron_pos_pct->setDoubleValue( FCS->GetDaLPos(ofNorm) );
right_aileron_pos_pct->setDoubleValue( -1*FCS->GetDaLPosN() ); right_aileron_pos_pct->setDoubleValue( -1*FCS->GetDaLPos(ofNorm) );
rudder_pos_pct->setDoubleValue( FCS->GetDrPosN() ); rudder_pos_pct->setDoubleValue( FCS->GetDrPos(ofNorm) );
flap_pos_pct->setDoubleValue( FCS->GetDfPosN() ); flap_pos_pct->setDoubleValue( FCS->GetDfPos(ofNorm) );
return true; return true;

1
src/FDM/JSBSim/Makefile.am
View file

@ -48,6 +48,7 @@ libJSBSim_a_SOURCES = \
FGEngine.cpp FGEngine.h \ FGEngine.cpp FGEngine.h \
FGTank.cpp FGTank.h \ FGTank.cpp FGTank.h \
FGfdmSocket.cpp FGfdmSocket.h \ FGfdmSocket.cpp FGfdmSocket.h \
FGPropertyManager.h \
JSBSim.cxx JSBSim.hxx JSBSim.cxx JSBSim.hxx