FGKinemat Class Reference

Encapsulates a kinematic (mechanical) component for the flight control system. More...

#include <FGKinemat.h>

Inheritance diagram for FGKinemat:

Collaboration diagram for FGKinemat:

Public Member Functions
	FGKinemat (FGFCS *fcs, Element *element)
	Constructor. More...
	~FGKinemat ()
	Destructor.
double	GetOutputPct () const
	Kinematic component output value. More...
bool	Run (void)
	Run method, overrides FGModel::Run(). More...
Public Member Functions inherited from FGFCSComponent
	FGFCSComponent (FGFCS *fcs, Element *el)
	Constructor.
virtual	~FGFCSComponent ()
	Destructor.
std::string	GetName (void) const
double	GetOutput (void) const
std::string	GetType (void) const
virtual void	ResetPastStates (void)
void	SetDtForFrameCount (int FrameCount)
virtual void	SetOutput (void)
Public Member Functions inherited from FGJSBBase
	FGJSBBase ()
	Constructor for FGJSBBase.
virtual	~FGJSBBase ()
	Destructor for FGJSBBase.
void	disableHighLighting (void)
	Disables highlighting in the console output.
std::string	GetVersion (void)
	Returns the version number of JSBSim. More...
void	PutMessage (const Message &msg)
	Places a Message structure on the Message queue. More...
void	PutMessage (const std::string &text)
	Creates a message with the given text and places it on the queue. More...
void	PutMessage (const std::string &text, bool bVal)
	Creates a message with the given text and boolean value and places it on the queue. More...
void	PutMessage (const std::string &text, int iVal)
	Creates a message with the given text and integer value and places it on the queue. More...
void	PutMessage (const std::string &text, double dVal)
	Creates a message with the given text and double value and places it on the queue. More...
int	SomeMessages (void)
	Reads the message on the queue (but does not delete it). More...
void	ProcessMessage (void)
	Reads the message on the queue and removes it from the queue. More...
Message *	ProcessNextMessage (void)
	Reads the next message on the queue and removes it from the queue. More...

Additional Inherited Members
Public Types inherited from FGJSBBase
enum	{ eL = 1, eM, eN }
	Moments L, M, N.
enum	{ eP = 1, eQ, eR }
	Rates P, Q, R.
enum	{ eU = 1, eV, eW }
	Velocities U, V, W.
enum	{ eX = 1, eY, eZ }
	Positions X, Y, Z.
enum	{ ePhi = 1, eTht, ePsi }
	Euler angles Phi, Theta, Psi.
enum	{ eDrag = 1, eSide, eLift }
	Stability axis forces, Drag, Side force, Lift.
enum	{ eRoll = 1, ePitch, eYaw }
	Local frame orientation Roll, Pitch, Yaw.
enum	{ eNorth = 1, eEast, eDown }
	Local frame position North, East, Down.
enum	{ eLat = 1, eLong, eRad }
	Locations Radius, Latitude, Longitude.
enum	{   inNone = 0, inDegrees, inRadians, inMeters,   inFeet }
	Conversion specifiers.
Static Public Member Functions inherited from FGJSBBase
static double	CelsiusToFahrenheit (double celsius)
	Converts from degrees Celsius to degrees Fahrenheit. More...
static double	CelsiusToKelvin (double celsius)
	Converts from degrees Celsius to degrees Kelvin. More...
static double	CelsiusToRankine (double celsius)
	Converts from degrees Celsius to degrees Rankine. More...
static double	Constrain (double min, double value, double max)
	Constrain a value between a minimum and a maximum value.
static bool	EqualToRoundoff (double a, double b)
	Finite precision comparison. More...
static bool	EqualToRoundoff (float a, float b)
	Finite precision comparison. More...
static bool	EqualToRoundoff (float a, double b)
	Finite precision comparison. More...
static bool	EqualToRoundoff (double a, float b)
	Finite precision comparison. More...
static double	FahrenheitToCelsius (double fahrenheit)
	Converts from degrees Fahrenheit to degrees Celsius. More...
static double	FeetToMeters (double measure)
	Converts from feet to meters. More...
static double	GaussianRandomNumber (void)
static double	KelvinToCelsius (double kelvin)
	Converts from degrees Kelvin to degrees Celsius. More...
static double	KelvinToFahrenheit (double kelvin)
	Converts from degrees Kelvin to degrees Fahrenheit. More...
static double	KelvinToRankine (double kelvin)
	Converts from degrees Kelvin to degrees Rankine. More...
static double	MachFromVcalibrated (double vcas, double p, double psl, double rhosl)
	Calculate the Mach number from the calibrated airspeed. More...
static double	PitotTotalPressure (double mach, double p)
	Compute the total pressure in front of the Pitot tube. More...
static double	RankineToCelsius (double rankine)
	Converts from degrees Rankine to degrees Celsius. More...
static double	RankineToKelvin (double rankine)
	Converts from degrees Rankine to degrees Kelvin. More...
static double	sign (double num)
static double	VcalibratedFromMach (double mach, double p, double psl, double rhosl)
	Calculate the calibrated airspeed from the Mach number. More...
Static Public Attributes inherited from FGJSBBase
static short	debug_lvl = 1
static char	highint [5] = {27, '[', '1', 'm', '\0' }
	highlights text
static char	halfint [5] = {27, '[', '2', 'm', '\0' }
	low intensity text
static char	normint [6] = {27, '[', '2', '2', 'm', '\0' }
	normal intensity text
static char	reset [5] = {27, '[', '0', 'm', '\0' }
	resets text properties
static char	underon [5] = {27, '[', '4', 'm', '\0' }
	underlines text
static char	underoff [6] = {27, '[', '2', '4', 'm', '\0' }
	underline off
static char	fgblue [6] = {27, '[', '3', '4', 'm', '\0' }
	blue text
static char	fgcyan [6] = {27, '[', '3', '6', 'm', '\0' }
	cyan text
static char	fgred [6] = {27, '[', '3', '1', 'm', '\0' }
	red text
static char	fggreen [6] = {27, '[', '3', '2', 'm', '\0' }
	green text
static char	fgdef [6] = {27, '[', '3', '9', 'm', '\0' }
	default text
Protected Member Functions inherited from FGFCSComponent
virtual void	bind ()
void	Clip (void)
void	Delay (void)
Protected Member Functions inherited from FGJSBBase
void	Debug (int)
Static Protected Member Functions inherited from FGJSBBase
static std::string	CreateIndexedPropertyName (const std::string &Property, int index)
Protected Attributes inherited from FGFCSComponent
bool	clip
double	clipmax
FGPropertyNode_ptr	ClipMaxPropertyNode
float	clipMaxSign
double	clipmin
FGPropertyNode_ptr	ClipMinPropertyNode
float	clipMinSign
unsigned int	delay
double	delay_time
double	dt
FGFCS *	fcs
int	index
std::vector< std::string >	InitNames
std::vector< FGPropertyValue * >	InitNodes
std::vector< float >	InitSigns
double	Input
std::vector< std::string >	InputNames
std::vector< FGPropertyValue * >	InputNodes
std::vector< float >	InputSigns
bool	IsOutput
std::string	Name
double	Output
std::vector< double >	output_array
std::vector< FGPropertyNode_ptr >	OutputNodes
FGPropertyManager *	PropertyManager
FGPropertyNode_ptr	treenode
std::string	Type
Static Protected Attributes inherited from FGJSBBase
static const double	degtorad = 0.017453292519943295769236907684886
static const double	fpstokts = 1.0/ktstofps
static const double	fttom = 0.3048
static int	gaussian_random_number_phase = 0
static const double	hptoftlbssec = 550.0
static const double	in3tom3 = 1.638706E-5
static const double	inchtoft = 0.08333333
static const double	inhgtopa = 3386.38
static const std::string	JSBSim_version = "1.0 " __DATE__ " " __TIME__
static const double	kgtolb = 2.20462
static const double	kgtoslug = 0.06852168
static const double	ktstofps = 1.68781
static const double	lbtoslug = 1.0/slugtolb
static Message	localMsg
static const double	m3toft3 = 1.0/(fttom*fttom*fttom)
static double	Mair = 28.9645
static unsigned int	messageId = 0
static std::queue< Message >	Messages
static const std::string	needed_cfg_version = "2.0"
static const double	psftoinhg = 0.014138
static const double	psftopa = 47.88
static const double	radtodeg = 57.295779513082320876798154814105
static double	Reng = 1716.56
static double	Rstar = 1545.348
static const double	SHRatio = 1.40
static const double	slugtolb = 32.174049

Detailed Description

Encapsulates a kinematic (mechanical) component for the flight control system.

This component models the action of a moving effector, such as an aerosurface or other mechanized entity such as a landing gear strut for the purpose of effecting vehicle control or configuration. The form of the component specification is:

<kinematic name="Gear Control">
  <input> [-]property </input>
  [<noscale/>]
  <traverse>
    <setting>
      <position> number </position>
      <time> number </time>
    </setting>
    ...
  </traverse>
  [<clipto>
    <min> {[-]property name | value} </min>
    <max> {[-]property name | value} </max>
  </clipto>]
  [<gain> {property name | value} </gain>]
  [<output> {property} </output>]
</kinematic>

The detent is the position that the component takes, and the lag is the time it takes to get to that position from an adjacent setting. For example:

<kinematic name="Gear Control">
  <input>gear/gear-cmd-norm</input>
  <traverse>
    <setting>
      <position>0</position>
      <time>0</time>
    </setting>
    <setting>
      <position>1</position>
      <time>5</time>
    </setting>
  </traverse>
  <output>gear/gear-pos-norm</output>
</kinematic>

In this case, it takes 5 seconds to get to a 1 setting. As this is a software mechanization of a servo-actuator, there should be an output specified.

Positions must be given in ascending order.

By default, the input is assumed to be in the range [-1;1] and is scaled to the value specified in the last <position> tag. This behavior can be modified by adding a <noscale> tag to the component definition: in that case, the input value is directly used to determine the current position of the component.

Definition at line 120 of file FGKinemat.h.

Constructor & Destructor Documentation

FGKinemat()

FGKinemat	(	FGFCS *	fcs,
		Element *	element
	)

Constructor.

Parameters

fcs	A reference to the current flight control system.
element	reference to the current configuration file node.

Definition at line 57 of file FGKinemat.cpp.

                                                 : FGFCSComponent(fcs, element)
{
  Element *traverse_element, *setting_element;
  double tmpDetent;
  double tmpTime;

  Detents.clear();
  TransitionTimes.clear();

  Output = 0;
  DoScale = true;

  if (element->FindElement("noscale")) DoScale = false;

  traverse_element = element->FindElement("traverse");
  setting_element = traverse_element->FindElement("setting");
  while (setting_element) {
    tmpDetent = setting_element->FindElementValueAsNumber("position");
    tmpTime = setting_element->FindElementValueAsNumber("time");
    Detents.push_back(tmpDetent);
    TransitionTimes.push_back(tmpTime);
    setting_element = traverse_element->FindNextElement("setting");
  }

  if (Detents.size() <= 1) {
    cerr << "Kinematic component " << Name
         << " must have more than 1 setting element" << endl;
    exit(-1);
  }

  FGFCSComponent::bind();

  Debug(0);
}

Here is the call graph for this function:

Member Function Documentation

GetOutputPct()

double GetOutputPct ( void  ) const

inlinevirtual

Kinematic component output value.

Returns

the current output of the kinematic object on the range of [0,1].

Reimplemented from FGFCSComponent.

Definition at line 133 of file FGKinemat.h.

  { return (Output-Detents[0])/(Detents.back()-Detents[0]); }

Here is the call graph for this function:

Run()

bool Run ( void  )

virtual

Run method, overrides FGModel::Run().

Returns

false on success, true on failure. The routine doing the work.

Reimplemented from FGFCSComponent.

Definition at line 101 of file FGKinemat.cpp.

{
  double dt0 = dt;

  Input = InputNodes[0]->getDoubleValue() * InputSigns[0];

  if (DoScale) Input *= Detents.back();

  if (IsOutput) Output = OutputNodes[0]->getDoubleValue();

  Input = Constrain(Detents.front(), Input, Detents.back());

  if (fcs->GetTrimStatus())
    // When trimming the output must be reached in one step
    Output = Input;
  else {
    // Process all detent intervals the movement traverses until either the
    // final value is reached or the time interval has finished.
    while ( dt0 > 0.0 && !EqualToRoundoff(Input, Output) ) {

      // Find the area where Output is in
      unsigned int ind;
      for (ind = 1; (Input < Output) ? Detents[ind] < Output : Detents[ind] <= Output ; ++ind)
        if (ind >= Detents.size())
          break;

      // A transition time of 0.0 means an infinite rate.
      // The output is reached in one step
      if (TransitionTimes[ind] <= 0.0) {
        Output = Input;
        break;
      } else {
        // Compute the rate in this area
        double Rate = (Detents[ind] - Detents[ind-1])/TransitionTimes[ind];
        // Compute the maximum input value inside this area
        double ThisInput = Constrain(Detents[ind-1], Input, Detents[ind]);
        // Compute the time to reach the value in ThisInput
        double ThisDt = fabs((ThisInput-Output)/Rate);

        // and clip to the timestep size
        if (dt0 < ThisDt) {
          ThisDt = dt0;
          if (Output < Input)
            Output += ThisDt*Rate;
          else
            Output -= ThisDt*Rate;
        } else
          // Handle this case separate to make shure the termination condition
          // is met even in inexact arithmetics ...
          Output = ThisInput;

        dt0 -= ThisDt;
      }
    }
  }

  Clip();
  if (IsOutput) SetOutput();

  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• FGKinemat.h
• FGKinemat.cpp