FGFCSComponent Class Reference

Detailed Description

Base class for JSBSim Flight Control System Components.

The Flight Control System (FCS) for JSBSim consists of the FCS container class (see FGFCS), the FGFCSComponent base class, and the component classes from which can be constructed a string, or channel. See:

• FGSwitch
• FGGain
• FGKinemat
• FGFilter
• FGDeadBand
• FGSummer
• FGSensor
• FGFCSFunction
• FGPID
• FGAccelerometer
• FGGyro
• FGActuator
• FGWwaypoint
• FGAngle

Author

Jon S. Berndt

See also

Documentation for the FGFCS class, and for the configuration file class

Definition at line 84 of file FGFCSComponent.h.

#include <FGFCSComponent.h>

Inheritance diagram for FGFCSComponent:

Collaboration diagram for FGFCSComponent:

Public Member Functions
	FGFCSComponent (FGFCS *fcs, Element *el)
	Constructor.
virtual	~FGFCSComponent ()
	Destructor.
std::string	GetName (void) const
double	GetOutput (void) const
virtual double	GetOutputPct (void) const
std::string	GetType (void) const
virtual void	ResetPastStates (void)
virtual bool	Run (void)
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.

Protected Member Functions
virtual void	bind (Element *el, FGPropertyManager *pm)
void	CheckInputNodes (size_t MinNodes, size_t MaxNodes, Element *el)
void	Clip (void)
virtual void	Debug (int from)
void	Delay (void)

Protected Attributes
bool	clip
FGParameter_ptr	ClipMax
FGParameter_ptr	ClipMin
bool	cyclic_clip
unsigned int	delay
double	delay_time
double	dt
FGFCS *	fcs
int	index
std::vector< FGPropertyValue_ptr >	InitNodes
double	Input
std::vector< FGPropertyValue_ptr >	InputNodes
std::string	Name
double	Output
std::vector< double >	output_array
std::vector< SGPropertyNode_ptr >	OutputNodes
std::string	Type

Additional Inherited Members
Public Types inherited from FGJSBBase
enum	{ eL = 1 , eM , eN }
	Moments L, M, N. More...
enum	{ eP = 1 , eQ , eR }
	Rates P, Q, R. More...
enum	{ eU = 1 , eV , eW }
	Velocities U, V, W. More...
enum	{ eX = 1 , eY , eZ }
	Positions X, Y, Z. More...
enum	{ ePhi = 1 , eTht , ePsi }
	Euler angles Phi, Theta, Psi. More...
enum	{ eDrag = 1 , eSide , eLift }
	Stability axis forces, Drag, Side force, Lift. More...
enum	{ eRoll = 1 , ePitch , eYaw }
	Local frame orientation Roll, Pitch, Yaw. More...
enum	{ eNorth = 1 , eEast , eDown }
	Local frame position North, East, Down. More...
enum	{ eLat = 1 , eLong , eRad }
	Locations Radius, Latitude, Longitude. More...
enum	{   inNone = 0 , inDegrees , inRadians , inMeters ,   inFeet }
	Conversion specifiers. More...
Static Public Member Functions inherited from FGJSBBase
static const std::string &	GetVersion (void)
	Returns the version number of JSBSim.
static constexpr double	KelvinToFahrenheit (double kelvin)
	Converts from degrees Kelvin to degrees Fahrenheit.
static constexpr double	CelsiusToRankine (double celsius)
	Converts from degrees Celsius to degrees Rankine.
static constexpr double	RankineToCelsius (double rankine)
	Converts from degrees Rankine to degrees Celsius.
static constexpr double	KelvinToRankine (double kelvin)
	Converts from degrees Kelvin to degrees Rankine.
static constexpr double	RankineToKelvin (double rankine)
	Converts from degrees Rankine to degrees Kelvin.
static constexpr double	FahrenheitToCelsius (double fahrenheit)
	Converts from degrees Fahrenheit to degrees Celsius.
static constexpr double	CelsiusToFahrenheit (double celsius)
	Converts from degrees Celsius to degrees Fahrenheit.
static constexpr double	CelsiusToKelvin (double celsius)
	Converts from degrees Celsius to degrees Kelvin.
static constexpr double	KelvinToCelsius (double kelvin)
	Converts from degrees Kelvin to degrees Celsius.
static constexpr double	FeetToMeters (double measure)
	Converts from feet to meters.
static bool	EqualToRoundoff (double a, double b)
	Finite precision comparison.
static bool	EqualToRoundoff (float a, float b)
	Finite precision comparison.
static bool	EqualToRoundoff (float a, double b)
	Finite precision comparison.
static bool	EqualToRoundoff (double a, float b)
	Finite precision comparison.
static constexpr double	Constrain (double min, double value, double max)
	Constrain a value between a minimum and a maximum value.
static constexpr double	sign (double num)
Static Public Attributes inherited from FGJSBBase
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
static short	debug_lvl = 1
Static Protected Member Functions inherited from FGJSBBase
static std::string	CreateIndexedPropertyName (const std::string &Property, int index)
Static Protected Attributes inherited from FGJSBBase
static constexpr double	radtodeg = 180. / M_PI
static constexpr double	degtorad = M_PI / 180.
static constexpr double	hptoftlbssec = 550.0
static constexpr double	psftoinhg = 0.014138
static constexpr double	psftopa = 47.88
static constexpr double	fttom = 0.3048
static constexpr double	ktstofps = 1852./(3600*fttom)
static constexpr double	fpstokts = 1.0 / ktstofps
static constexpr double	inchtoft = 1.0/12.0
static constexpr double	m3toft3 = 1.0/(fttom*fttom*fttom)
static constexpr double	in3tom3 = inchtoft*inchtoft*inchtoft/m3toft3
static constexpr double	inhgtopa = 3386.38
static constexpr double	slugtolb = 32.174049
	Note that definition of lbtoslug by the inverse of slugtolb and not to a different constant you can also get from some tables will make lbtoslug*slugtolb == 1 up to the magnitude of roundoff.
static constexpr double	lbtoslug = 1.0/slugtolb
static constexpr double	kgtolb = 2.20462
static constexpr double	kgtoslug = 0.06852168
static const std::string	needed_cfg_version = "2.0"
static const std::string	JSBSim_version = JSBSIM_VERSION " " __DATE__ " " __TIME__

Constructor & Destructor Documentation

FGFCSComponent()

FGFCSComponent	(	FGFCS *	fcs,
		Element *	el
	)

Constructor.

Definition at line 53 of file FGFCSComponent.cpp.

                                                            : fcs(_fcs)
{
  Input = Output = delay_time = 0.0;
  delay = index = 0;
  ClipMin = ClipMax = new FGRealValue(0.0);
  clip = cyclic_clip = false;
  dt = fcs->GetChannelDeltaT();
 
  auto PropertyManager = fcs->GetPropertyManager();
  if        (element->GetName() == string("lag_filter")) {
    Type = "LAG_FILTER";
  } else if (element->GetName() == string("lead_lag_filter")) {
    Type = "LEAD_LAG_FILTER";
  } else if (element->GetName() == string("washout_filter")) {
    Type = "WASHOUT_FILTER";
  } else if (element->GetName() == string("second_order_filter")) {
    Type = "SECOND_ORDER_FILTER";
  } else if (element->GetName() == string("integrator")) {
    Type = "INTEGRATOR";
  } else if (element->GetName() == string("summer")) {
    Type = "SUMMER";
  } else if (element->GetName() == string("pure_gain")) {
    Type = "PURE_GAIN";
  } else if (element->GetName() == string("scheduled_gain")) {
    Type = "SCHEDULED_GAIN";
  } else if (element->GetName() == string("aerosurface_scale")) {
    Type = "AEROSURFACE_SCALE";
  } else if (element->GetName() == string("switch")) {
    Type = "SWITCH";
  } else if (element->GetName() == string("kinematic")) {
    Type = "KINEMATIC";
  } else if (element->GetName() == string("deadband")) {
    Type = "DEADBAND";
  } else if (element->GetName() == string("fcs_function")) {
    Type = "FCS_FUNCTION";
  } else if (element->GetName() == string("pid")) {
    Type = "PID";
  } else if (element->GetName() == string("sensor")) {
    Type = "SENSOR";
  } else if (element->GetName() == string("accelerometer")) {
    Type = "ACCELEROMETER";
  } else if (element->GetName() == string("magnetometer")) {
    Type = "MAGNETOMETER";
  } else if (element->GetName() == string("gyro")) {
    Type = "GYRO";
  } else if (element->GetName() == string("actuator")) {
    Type = "ACTUATOR";
  } else if (element->GetName() == string("waypoint_heading")) {
    Type = "WAYPOINT_HEADING";
  } else if (element->GetName() == string("waypoint_distance")) {
    Type = "WAYPOINT_DISTANCE";
  } else if (element->GetName() == string("angle")) {
    Type = "ANGLE";
  } else if (element->GetName() == string("distributor")) {
    Type = "DISTRIBUTOR";
  } else { // illegal component in this channel
    Type = "UNKNOWN";
  }
 
  Name = element->GetAttributeValue("name");
 
  Element *init_element = element->FindElement("init");
  while (init_element) {
    InitNodes.push_back(new FGPropertyValue(init_element->GetDataLine(),
                                            PropertyManager, init_element));
    init_element = element->FindNextElement("init");
  }
 
  Element *input_element = element->FindElement("input");
  while (input_element) {
    InputNodes.push_back(new FGPropertyValue(input_element->GetDataLine(),
                                             PropertyManager, input_element));
 
    input_element = element->FindNextElement("input");
  }
 
  Element *out_elem = element->FindElement("output");
  while (out_elem) {
    string output_node_name = out_elem->GetDataLine();
    bool node_exists = PropertyManager->HasNode(output_node_name);
    SGPropertyNode* OutputNode = PropertyManager->GetNode( output_node_name, true );
    if (!OutputNode) {
      XMLLogException err(out_elem);
      err << "  Unable to process property: " << output_node_name << "\n";
      throw err;
    }
    OutputNodes.push_back(OutputNode);
    // If the node has just been created then it must be initialized to a
    // sensible value since FGPropertyNode::GetNode() does not take care of
    // that.  If the node was already existing, its current value is kept
    // unchanged.
    if (!node_exists)
      OutputNode->setDoubleValue(Output);
    out_elem = element->FindNextElement("output");
  }
 
  Element* delay_elem = element->FindElement("delay");
  if ( delay_elem ) {
    string delay_str = delay_elem->GetDataLine();
    FGParameterValue delayParam(delay_str, PropertyManager, delay_elem);
    delay_time = delayParam.GetValue();
    string delayType = delay_elem->GetAttributeValue("type");
    if (delayType.length() > 0) {
      if (delayType == "time") {
        delay = (unsigned int)(delay_time / dt);
      } else if (delayType == "frames") {
        delay = (unsigned int)delay_time;
      } else {
        FGXMLLogging log(delay_elem, LogLevel::ERROR);
        log << "Unallowed delay type\n";
      }
    } else {
      delay = (unsigned int)(delay_time / dt);
    }
    output_array.resize(delay);
    for (unsigned int i=0; i<delay; i++) output_array[i] = 0.0;
  }
 
  Element *clip_el = element->FindElement("clipto");
  if (clip_el) {
    Element* el = clip_el->FindElement("min");
    if (!el) {
      FGXMLLogging log(clip_el, LogLevel::ERROR);
      log << "Element <min> is missing, <clipto> is ignored.\n";
      return;
    }
 
    ClipMin = new FGParameterValue(el, PropertyManager);
 
    el = clip_el->FindElement("max");
    if (!el) {
      FGXMLLogging log(clip_el, LogLevel::ERROR);
      log << "Element <max> is missing, <clipto> is ignored.\n";
      ClipMin = nullptr;
      return;
    }
 
    ClipMax = new FGParameterValue(el, PropertyManager);
 
    if (clip_el->GetAttributeValue("type") == "cyclic")
      cyclic_clip = true;
 
    clip = true;
  }
 
  Debug(0);
}

Here is the call graph for this function:

~FGFCSComponent()

~FGFCSComponent ( )

virtual

Destructor.

Definition at line 203 of file FGFCSComponent.cpp.

{
  Debug(1);
}

Member Function Documentation

bind()

void bind ( Element *  el, FGPropertyManager *  pm  )

protectedvirtual

Definition at line 303 of file FGFCSComponent.cpp.

{
  string tmp;
  if (Name.find("/") == string::npos)
    tmp = "fcs/" + PropertyManager->mkPropertyName(Name, true);
  else
    tmp = Name;
 
  bool node_exists = PropertyManager->HasNode(tmp);
  SGPropertyNode* node = PropertyManager->GetNode(tmp, true);
 
  if (node) {
    OutputNodes.push_back(node);
    // If the node has just been created then it must be initialized to a
    // sensible value since FGPropertyNode::GetNode() does not take care of
    // that.  If the node was already existing, its current value is kept
    // unchanged.
    if (!node_exists)
      node->setDoubleValue(Output);
  }
  else {
    FGXMLLogging log(el, LogLevel::ERROR);
    log << "Could not get or create property " << tmp << "\n";
  }
}

CheckInputNodes()

void CheckInputNodes ( size_t  MinNodes, size_t  MaxNodes, Element *  el  )

protected

Definition at line 219 of file FGFCSComponent.cpp.

{
  size_t num = InputNodes.size();
 
  if (num < MinNodes) {
    XMLLogException err(el);
    err << "    Not enough <input> nodes are provided\n"
        << "    Expecting " << MinNodes << " while " << num
        << " are provided.\n";
    throw err;
  }
 
  if (num > MaxNodes) {
    FGXMLLogging log(el, LogLevel::ERROR);
    log << "    Too many <input> nodes are provided\n"
        << "    Expecting " << MaxNodes << " while " << num
        << " are provided.\n"
        << "    The last " << num-MaxNodes << " input nodes will be ignored.\n";
  }
}

Clip()

void Clip ( void  )

protected

Definition at line 267 of file FGFCSComponent.cpp.

{
  if (clip) {
    double vmin = ClipMin->GetValue();
    double vmax = ClipMax->GetValue();
    double range = vmax - vmin;
 
    if (range < 0.0) {
      FGLogging log(LogLevel::ERROR);
      log << "Trying to clip with a max value (" << fixed << vmax << ") from "
          << ClipMax->GetName() << " lower than the min value (" << vmin
          << ") from " << ClipMin->GetName() << ".\n"
          << "Clipping is ignored.\n";
      return;
    }
 
    if (cyclic_clip && range != 0.0) {
      double value = Output - vmin;
      Output = fmod(value, range) + vmin;
      if (Output < vmin)
        Output += range;
    }
    else
      Output = Constrain(vmin, Output, vmax);
  }
}

Debug()

void Debug ( int  from )

protectedvirtual

Definition at line 348 of file FGFCSComponent.cpp.

{
  if (debug_lvl <= 0) return;
 
  if (debug_lvl & 1) { // Standard console startup message output
    if (from == 0) {
      FGLogging log(LogLevel::DEBUG);
      log << "\n    Loading Component \"" << Name << fixed
          << "\" of type: " << Type << "\n";
 
      if (clip) {
        log << "      Minimum limit: " << ClipMin->GetName() << "\n";
        log << "      Maximum limit: " << ClipMax->GetName() << "\n";
      }
      if (delay > 0) log <<"      Frame delay: " << delay << fixed
                         << setprecision(4) << " frames (" << delay*dt << " sec)\n";
    }
  }
  if (debug_lvl & 2 ) { // Instantiation/Destruction notification
    FGLogging log(LogLevel::DEBUG);
    if (from == 0) log << "Instantiated: FGFCSComponent\n";
    if (from == 1) log << "Destroyed:    FGFCSComponent\n";
  }
  if (debug_lvl & 4 ) { // Run() method entry print for FGModel-derived objects
  }
  if (debug_lvl & 8 ) { // Runtime state variables
  }
  if (debug_lvl & 16) { // Sanity checking
  }
  if (debug_lvl & 64) {
    if (from == 0) { // Constructor
    }
  }
}

Delay()

void Delay ( void  )

protected

Definition at line 250 of file FGFCSComponent.cpp.

{
  if (fcs->GetTrimStatus()) {
    // Update the whole history while trim routines are executing.
    // Don't want to model delays while calculating a trim solution.
    std::fill(output_array.begin(), output_array.end(), Output);
  }
  else {
    output_array[index] = Output;
    if ((unsigned int)index == delay-1) index = 0;
    else index++;
    Output = output_array[index];
  }
}

GetName()

std::string GetName ( void  ) const

inline

Definition at line 95 of file FGFCSComponent.h.

{return Name;}

GetOutput()

double GetOutput ( void  ) const

inline

Definition at line 94 of file FGFCSComponent.h.

{return Output;}

GetOutputPct()

virtual double GetOutputPct ( void  ) const

inlinevirtual

Reimplemented in FGKinemat.

Definition at line 97 of file FGFCSComponent.h.

{ return 0; }

GetType()

std::string GetType ( void  ) const

inline

Definition at line 96 of file FGFCSComponent.h.

{ return Type; }

ResetPastStates()

void ResetPastStates ( void  )

virtual

Definition at line 210 of file FGFCSComponent.cpp.

{
  index = 0;
  for (auto &elm: output_array)
    elm = 0.0;
}

Run()

virtual bool Run ( void  )

inlinevirtual

Reimplemented in FGActuator, FGDistributor, FGKinemat, FGLinearActuator, FGSummer, and FGSwitch.

Definition at line 92 of file FGFCSComponent.h.

{ return true; }

SetOutput()

void SetOutput ( void  )

virtual

Definition at line 242 of file FGFCSComponent.cpp.

{
  for (auto node: OutputNodes)
    node->setDoubleValue(Output);
}

Member Data Documentation

clip

bool clip

protected

Definition at line 115 of file FGFCSComponent.h.

ClipMax

FGParameter_ptr ClipMax

protected

Definition at line 103 of file FGFCSComponent.h.

ClipMin

FGParameter_ptr ClipMin

protected

Definition at line 103 of file FGFCSComponent.h.

cyclic_clip

bool cyclic_clip

protected

Definition at line 115 of file FGFCSComponent.h.

delay

unsigned int delay

protected

Definition at line 112 of file FGFCSComponent.h.

delay_time

double delay_time

protected

Definition at line 111 of file FGFCSComponent.h.

dt

double dt

protected

Definition at line 114 of file FGFCSComponent.h.

fcs

FGFCS* fcs

protected

Definition at line 101 of file FGFCSComponent.h.

index

int index

protected

Definition at line 113 of file FGFCSComponent.h.

InitNodes

std::vector<FGPropertyValue_ptr> InitNodes

protected

Definition at line 104 of file FGFCSComponent.h.

Input

double Input

protected

Definition at line 109 of file FGFCSComponent.h.

InputNodes

std::vector<FGPropertyValue_ptr> InputNodes

protected

Definition at line 105 of file FGFCSComponent.h.

Name

std::string Name

protected

Definition at line 108 of file FGFCSComponent.h.

Output

double Output

protected

Definition at line 110 of file FGFCSComponent.h.

output_array

std::vector<double> output_array

protected

Definition at line 106 of file FGFCSComponent.h.

OutputNodes

std::vector<SGPropertyNode_ptr> OutputNodes

protected

Definition at line 102 of file FGFCSComponent.h.

Type

std::string Type

protected

Definition at line 107 of file FGFCSComponent.h.

---

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

• FGFCSComponent.h
• FGFCSComponent.cpp