FGOutputSocket Class Reference

Detailed Description

Implements the output to a socket.

This class outputs data to a socket according to the JSBSim format. It can be inherited as a generic class that provides services for socket outputs. For instance FGOutputFG inherits FGOutputSocket for the socket management but outputs data with a format different than FGOutputSocket.

Definition at line 66 of file FGOutputSocket.h.

#include <FGOutputSocket.h>

Inheritance diagram for FGOutputSocket:

Collaboration diagram for FGOutputSocket:

Public Member Functions
	FGOutputSocket (FGFDMExec *fdmex)
	Constructor.
	~FGOutputSocket () override
	Destructor.
bool	InitModel (void) override
	Initializes the instance.
bool	Load (Element *el) override
	Init the output directives from an XML file.
void	Print (void) override
	Generates the output.
void	SetOutputName (const std::string &name) override
	Overwrites the name identifier under which the output will be logged.
void	SocketStatusOutput (const std::string &out_str)
	Outputs a status thru the socket.
Public Member Functions inherited from FGOutputType
	FGOutputType (FGFDMExec *fdmex)
	Constructor (implement the FGModel interface).
	~FGOutputType () override
	Destructor.
void	Disable (void)
	Disables the output generation.
void	Enable (void)
	Enables the output generation.
virtual const std::string &	GetOutputName (void) const
	Get the name identifier to which the output will be directed.
double	GetRateHz (void) const
	Get the output rate in Hz for this output.
bool	InitModel (void) override
	Init the output model according to its configitation.
bool	Load (Element *el) override
	Init the output directives from an XML file (implement the FGModel interface).
bool	Run (bool Holding) override
	Executes the output directives (implement the FGModel interface).
void	SetIdx (unsigned int idx)
	Set the idx for this output instance.
void	SetOutputProperties (std::vector< FGPropertyNode_ptr > &outputProperties)
	Set the list of properties that should be output for this output instance.
void	SetRateHz (double rtHz)
	Set the output rate for this output instances.
virtual void	SetStartNewOutput (void)
	Reset the output prior to a restart of the simulation.
void	SetSubSystems (int subSystems)
	Set the activated subsystems for this output instance.
bool	Toggle (void)
	Toggles the output generation.
Public Member Functions inherited from FGModel
	FGModel (FGFDMExec *)
	Constructor.
	~FGModel () override
	Destructor.
virtual SGPath	FindFullPathName (const SGPath &path) const
FGFDMExec *	GetExec (void)
const std::string &	GetName (void)
unsigned int	GetRate (void)
	Get the output rate for the model in frames.
void	SetPropertyManager (std::shared_ptr< FGPropertyManager > fgpm)
void	SetRate (unsigned int tt)
	Set the ouput rate for the model in frames.
Public Member Functions inherited from FGModelFunctions
std::string	GetFunctionStrings (const std::string &delimeter) const
	Gets the strings for the current set of functions.
std::string	GetFunctionValues (const std::string &delimeter) const
	Gets the function values.
std::shared_ptr< FGFunction >	GetPreFunction (const std::string &name)
	Get one of the "pre" function.
bool	Load (Element *el, FGFDMExec *fdmex, std::string prefix="")
void	PostLoad (Element *el, FGFDMExec *fdmex, std::string prefix="")
void	PreLoad (Element *el, FGFDMExec *fdmex, std::string prefix="")
void	RunPostFunctions (void)
void	RunPreFunctions (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	PrintHeaders (void)
Protected Member Functions inherited from FGOutputType
void	Debug (int from) override
Protected Member Functions inherited from FGModel
bool	Upload (Element *el, bool preLoad)
	Uploads this model in memory.

Protected Attributes
int	precision
FGfdmSocket *	socket
std::string	SockName
unsigned int	SockPort
FGfdmSocket::ProtocolType	SockProtocol
Protected Attributes inherited from FGOutputType
std::shared_ptr< FGAccelerations >	Accelerations
std::shared_ptr< FGAerodynamics >	Aerodynamics
std::shared_ptr< FGAircraft >	Aircraft
std::shared_ptr< FGAuxiliary >	Auxiliary
std::shared_ptr< FGBuoyantForces >	BuoyantForces
bool	enabled
std::shared_ptr< FGExternalReactions >	ExternalReactions
std::shared_ptr< FGFCS >	FCS
std::shared_ptr< FGGroundReactions >	GroundReactions
std::shared_ptr< FGMassBalance >	MassBalance
std::vector< std::string >	OutputCaptions
unsigned int	OutputIdx
std::vector< FGPropertyValue * >	OutputParameters
std::shared_ptr< FGPropagate >	Propagate
std::shared_ptr< FGPropulsion >	Propulsion
int	SubSystems
std::shared_ptr< FGWinds >	Winds
Protected Attributes inherited from FGModel
unsigned int	exe_ctr
FGFDMExec *	FDMExec
std::string	Name
std::shared_ptr< FGPropertyManager >	PropertyManager
unsigned int	rate
Protected Attributes inherited from FGModelFunctions
FGPropertyReader	LocalProperties
std::vector< std::shared_ptr< FGFunction > >	PostFunctions
std::vector< std::shared_ptr< FGFunction > >	PreFunctions

Additional Inherited Members
Public Types inherited from FGOutputType
enum	eSubSystems {   ssSimulation = 1 , ssAerosurfaces = 2 , ssRates = 4 , ssVelocities = 8 ,   ssForces = 16 , ssMoments = 32 , ssAtmosphere = 64 , ssMassProps = 128 ,   ssAeroFunctions = 256 , ssPropagate = 512 , ssGroundReactions = 1024 , ssFCS = 2048 ,   ssPropulsion = 4096 }
	Subsystem types for specifying which will be output in the FDM data logging. More...
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)
Public Attributes inherited from FGOutputType
enum JSBSim::FGOutputType::eSubSystems	subsystems
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

FGOutputSocket()

FGOutputSocket

(

FGFDMExec *

fdmex

)

Constructor.

Definition at line 69 of file FGOutputSocket.cpp.

                                               :
  FGOutputType(fdmex),
  socket(0)
{
}

~FGOutputSocket()

~FGOutputSocket ( )

override

Destructor.

Definition at line 77 of file FGOutputSocket.cpp.

{
  delete socket;
}

Member Function Documentation

InitModel()

bool InitModel ( void  )

overridevirtual

Initializes the instance.

This method basically opens the socket to which outputs will be directed.

Returns

true if the execution succeeded.

Reimplemented from FGModel.

Definition at line 136 of file FGOutputSocket.cpp.

{
  if (FGOutputType::InitModel()) {
    delete socket;
    socket = new FGfdmSocket(SockName, SockPort, SockProtocol, precision);
 
    if (socket == 0) return false;
    if (!socket->GetConnectStatus()) return false;
 
    PrintHeaders();
 
    return true;
  }
 
  return false;
}

Here is the call graph for this function:

Load()

bool Load ( Element *  el )

overridevirtual

Init the output directives from an XML file.

Parameters

element

XML Element that is pointing to the output directives

Reimplemented from FGModel.

Definition at line 116 of file FGOutputSocket.cpp.

{
  if (!FGOutputType::Load(el))
    return false;
 
  SetOutputName(el->GetAttributeValue("name") + ":" +
                el->GetAttributeValue("protocol") + "/" +
                el->GetAttributeValue("port"));
 
  // Check if output precision for doubles has been specified, default to 7 if not
  if(el->HasAttribute("precision"))
    precision = (int)el->GetAttributeValueAsNumber("precision");
  else
    precision = 7;
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Print()

void Print ( void  )

overridevirtual

Generates the output.

Implements FGOutputType.

Definition at line 280 of file FGOutputSocket.cpp.

{
  string asciiData, scratch;
 
  if (socket == 0) return;
  if (!socket->GetConnectStatus()) return;
 
  socket->Clear();
  socket->Append(FDMExec->GetSimTime());
 
  if (SubSystems & ssAerosurfaces) {
    socket->Append(FCS->GetDaCmd());
    socket->Append(FCS->GetDeCmd());
    socket->Append(FCS->GetDrCmd());
    socket->Append(FCS->GetDfCmd());
    socket->Append(FCS->GetDaLPos());
    socket->Append(FCS->GetDaRPos());
    socket->Append(FCS->GetDePos());
    socket->Append(FCS->GetDrPos());
    socket->Append(FCS->GetDfPos());
  }
  if (SubSystems & ssRates) {
    socket->Append(radtodeg*Propagate->GetPQR(eP));
    socket->Append(radtodeg*Propagate->GetPQR(eQ));
    socket->Append(radtodeg*Propagate->GetPQR(eR));
    socket->Append(radtodeg*Accelerations->GetPQRdot(eP));
    socket->Append(radtodeg*Accelerations->GetPQRdot(eQ));
    socket->Append(radtodeg*Accelerations->GetPQRdot(eR));
  }
  if (SubSystems & ssVelocities) {
    socket->Append(Auxiliary->Getqbar());
    socket->Append(Auxiliary->GetVt());
    socket->Append(Propagate->GetUVW(eU));
    socket->Append(Propagate->GetUVW(eV));
    socket->Append(Propagate->GetUVW(eW));
    socket->Append(Auxiliary->GetAeroUVW(eU));
    socket->Append(Auxiliary->GetAeroUVW(eV));
    socket->Append(Auxiliary->GetAeroUVW(eW));
    socket->Append(Propagate->GetVel(eNorth));
    socket->Append(Propagate->GetVel(eEast));
    socket->Append(Propagate->GetVel(eDown));
  }
  if (SubSystems & ssForces) {
    socket->Append(Aerodynamics->GetvFw()(eDrag));
    socket->Append(Aerodynamics->GetvFw()(eSide));
    socket->Append(Aerodynamics->GetvFw()(eLift));
    socket->Append(Aerodynamics->GetLoD());
    socket->Append(Aircraft->GetForces(eX));
    socket->Append(Aircraft->GetForces(eY));
    socket->Append(Aircraft->GetForces(eZ));
  }
  if (SubSystems & ssMoments) {
    socket->Append(Aircraft->GetMoments(eL));
    socket->Append(Aircraft->GetMoments(eM));
    socket->Append(Aircraft->GetMoments(eN));
  }
  if (SubSystems & ssAtmosphere) {
    const auto Atmosphere = FDMExec->GetAtmosphere();
    socket->Append(Atmosphere->GetDensity());
    socket->Append(Atmosphere->GetPressureSL());
    socket->Append(Atmosphere->GetPressure());
    socket->Append(Winds->GetTurbMagnitude());
    socket->Append(Winds->GetTurbDirection());
    socket->Append(Winds->GetTotalWindNED().Dump(","));
  }
  if (SubSystems & ssMassProps) {
    socket->Append(MassBalance->GetJ()(1,1));
    socket->Append(MassBalance->GetJ()(1,2));
    socket->Append(MassBalance->GetJ()(1,3));
    socket->Append(MassBalance->GetJ()(2,1));
    socket->Append(MassBalance->GetJ()(2,2));
    socket->Append(MassBalance->GetJ()(2,3));
    socket->Append(MassBalance->GetJ()(3,1));
    socket->Append(MassBalance->GetJ()(3,2));
    socket->Append(MassBalance->GetJ()(3,3));
    socket->Append(MassBalance->GetMass());
    socket->Append(MassBalance->GetXYZcg()(eX));
    socket->Append(MassBalance->GetXYZcg()(eY));
    socket->Append(MassBalance->GetXYZcg()(eZ));
  }
  if (SubSystems & ssPropagate) {
    socket->Append(Propagate->GetAltitudeASL());
    socket->Append(radtodeg*Propagate->GetEuler(ePhi));
    socket->Append(radtodeg*Propagate->GetEuler(eTht));
    socket->Append(radtodeg*Propagate->GetEuler(ePsi));
    socket->Append(Auxiliary->Getalpha(inDegrees));
    socket->Append(Auxiliary->Getbeta(inDegrees));
    socket->Append(Propagate->GetLocation().GetLatitudeDeg());
    socket->Append(Propagate->GetLocation().GetLongitudeDeg());
  }
  if (SubSystems & ssAeroFunctions) {
    scratch = Aerodynamics->GetAeroFunctionValues(",");
    if (scratch.length() != 0) socket->Append(scratch);
  }
  if (SubSystems & ssFCS) {
    scratch = FCS->GetComponentValues(",");
    if (scratch.length() != 0) socket->Append(scratch);
  }
  if (SubSystems & ssGroundReactions) {
    socket->Append(GroundReactions->GetGroundReactionValues(","));
  }
  if (SubSystems & ssPropulsion && Propulsion->GetNumEngines() > 0) {
    socket->Append(Propulsion->GetPropulsionValues(","));
  }
 
  for (unsigned int i=0;i<OutputParameters.size();++i) {
    socket->Append(OutputParameters[i]->GetValue());
  }
 
  socket->Send();
}

Here is the call graph for this function:

PrintHeaders()

void PrintHeaders ( void  )

protectedvirtual

Definition at line 155 of file FGOutputSocket.cpp.

{
  string scratch;
 
  socket->Clear();
  socket->Clear("<LABELS>");
  socket->Append("Time");
 
  if (SubSystems & ssAerosurfaces) {
    socket->Append("Aileron Command");
    socket->Append("Elevator Command");
    socket->Append("Rudder Command");
    socket->Append("Flap Command");
    socket->Append("Left Aileron Position");
    socket->Append("Right Aileron Position");
    socket->Append("Elevator Position");
    socket->Append("Rudder Position");
    socket->Append("Flap Position");
  }
 
  if (SubSystems & ssRates) {
    socket->Append("P");
    socket->Append("Q");
    socket->Append("R");
    socket->Append("PDot");
    socket->Append("QDot");
    socket->Append("RDot");
  }
 
  if (SubSystems & ssVelocities) {
    socket->Append("QBar");
    socket->Append("Vtotal");
    socket->Append("UBody");
    socket->Append("VBody");
    socket->Append("WBody");
    socket->Append("UAero");
    socket->Append("VAero");
    socket->Append("WAero");
    socket->Append("Vn");
    socket->Append("Ve");
    socket->Append("Vd");
  }
 
  if (SubSystems & ssForces) {
    socket->Append("F_Drag");
    socket->Append("F_Side");
    socket->Append("F_Lift");
    socket->Append("LoD");
    socket->Append("Fx");
    socket->Append("Fy");
    socket->Append("Fz");
  }
 
  if (SubSystems & ssMoments) {
    socket->Append("L");
    socket->Append("M");
    socket->Append("N");
  }
 
  if (SubSystems & ssAtmosphere) {
    socket->Append("Rho");
    socket->Append("SL pressure");
    socket->Append("Ambient pressure");
    socket->Append("Turbulence Magnitude");
    socket->Append("Turbulence Direction");
    socket->Append("NWind");
    socket->Append("EWind");
    socket->Append("DWind");
  }
 
  if (SubSystems & ssMassProps) {
    socket->Append("Ixx");
    socket->Append("Ixy");
    socket->Append("Ixz");
    socket->Append("Iyx");
    socket->Append("Iyy");
    socket->Append("Iyz");
    socket->Append("Izx");
    socket->Append("Izy");
    socket->Append("Izz");
    socket->Append("Mass");
    socket->Append("Xcg");
    socket->Append("Ycg");
    socket->Append("Zcg");
  }
 
  if (SubSystems & ssPropagate) {
    socket->Append("Altitude");
    socket->Append("Phi (deg)");
    socket->Append("Tht (deg)");
    socket->Append("Psi (deg)");
    socket->Append("Alpha (deg)");
    socket->Append("Beta (deg)");
    socket->Append("Latitude (deg)");
    socket->Append("Longitude (deg)");
  }
 
  if (SubSystems & ssAeroFunctions) {
    scratch = Aerodynamics->GetAeroFunctionStrings(",");
    if (scratch.length() != 0) socket->Append(scratch);
  }
 
  if (SubSystems & ssFCS) {
    scratch = FCS->GetComponentStrings(",");
    if (scratch.length() != 0) socket->Append(scratch);
  }
 
  if (SubSystems & ssGroundReactions)
    socket->Append(GroundReactions->GetGroundReactionStrings(","));
 
  if (SubSystems & ssPropulsion && Propulsion->GetNumEngines() > 0)
    socket->Append(Propulsion->GetPropulsionStrings(","));
 
  for (unsigned int i=0;i<OutputParameters.size();++i) {
    if (!OutputCaptions[i].empty())
      socket->Append(OutputCaptions[i]);
    else
      socket->Append(OutputParameters[i]->GetPrintableName());
  }
 
  socket->Send();
}

SetOutputName()

void SetOutputName ( const std::string &  name )

overridevirtual

Overwrites the name identifier under which the output will be logged.

This method is taken into account if it is called before FGFDMExec::RunIC() otherwise it is ignored until the next call to SetStartNewOutput().

Parameters

name	new name in the form "hostname:port/proto" hostname could be an ip, port a numerical value and proto should be UDP or TCP (the default if omitted)

Reimplemented from FGOutputType.

Definition at line 84 of file FGOutputSocket.cpp.

{
  // tokenize the output name
  size_t dot_pos = fname.find(':', 0);
  size_t slash_pos = fname.find('/', 0);
 
  string name = fname.substr(0, dot_pos);
 
  string proto = "TCP";
  if(dot_pos + 1 < slash_pos)
    proto = fname.substr(dot_pos + 1, slash_pos - dot_pos - 1);
 
  string port = "1138";
  if(slash_pos < string::npos)
    port = fname.substr(slash_pos + 1, string::npos);
 
  // set the model name
  Name = name + ":" + port + "/" + proto;
 
  // set the socket params
  SockName = name;
 
  SockPort = atoi(port.c_str());
 
  if (to_upper(proto) == "UDP")
    SockProtocol = FGfdmSocket::ptUDP;
  else // Default to TCP
    SockProtocol = FGfdmSocket::ptTCP;
}

Here is the caller graph for this function:

SocketStatusOutput()

void SocketStatusOutput

(

const std::string &

out_str

)

Outputs a status thru the socket.

This method issues a message prepended by the string "<STATUS>" to the socket.

Parameters

out_str

status message

Definition at line 394 of file FGOutputSocket.cpp.

{
  string asciiData;
 
  if (socket == 0) return;
 
  socket->Clear();
  asciiData = string("<STATUS>") + out_str;
  socket->Append(asciiData.c_str());
  socket->Send();
}

Here is the call graph for this function:

Member Data Documentation

precision

int precision

protected

Definition at line 111 of file FGOutputSocket.h.

socket

FGfdmSocket* socket

protected

Definition at line 110 of file FGOutputSocket.h.

SockName

std::string SockName

protected

Definition at line 107 of file FGOutputSocket.h.

SockPort

unsigned int SockPort

protected

Definition at line 108 of file FGOutputSocket.h.

SockProtocol

FGfdmSocket::ProtocolType SockProtocol

protected

Definition at line 109 of file FGOutputSocket.h.

---

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

• FGOutputSocket.h
• FGOutputSocket.cpp