Generated reference › EOM 6DOF Wind Angles — Robotics/Equations Of Motion
kind: generated#block#robotics-equations-of-motion

EOM 6DOF Wind Angles — Robotics/Equations Of Motion

Robotics/Equations_Of_Motion/EOM_6DOF_Wind_Angles · 2 input / 10 output port(s) at insert · exports to Python, MATLAB, Java, Rust, C, C++, VHDL, Verilog, SystemVerilog, PLC Structured Text

Description#

The block's own DESCRIPTION_HTML, rendered verbatim — the same text the config dialog's info panel and the library navigator show. Fix a wrong sentence in the block's .cpp (R-D9), never here.

EOM 6DOF Wind Angles

Robotics / Equations Of Motion

The six-degree-of-freedom equations of motion of a rigid body of fixed mass, carried in wind axes: the velocity is the airspeed V with the incidence α and the sideslip β, and the attitude is the wind angles – bank μ, flight-path angle γ and heading χ (the 3-2-1 sequence from the flat-earth frame to wind axes). With the applied force F in wind axes, a = F/m, the body rates ω = [p; q; r], the inertia tensor I and DCMwb the body-to-wind rotation of (α, β):

  • V' = ax
  • β' = p·sin α − r·cos α + ay/V
  • α' = q − (p·cos α + r·sin α)·tan β + az/(V·cos β)
  • [pw; qw; rw] = DCMwb·[p − β'·sin α; q − α'; r + β'·cos α], the wind-axis rates
  • μ' = pw + (qw·sin μ + rw·cos μ)·tan γ, γ' = qw·cos μ − rw·sin μ, χ' = (qw·sin μ + rw·cos μ)/cos γ
  • ω' = I−T(M − ω × (Iω))
  • Xe' = DCMweT·[V; 0; 0]

Ports

  • F – the applied force in wind axes, [3,1].
  • M – the applied moment about the centre of gravity in body axes, [3,1].
  • Ve – the velocity in the flat-earth frame, DCMweT·[V; 0; 0], [3,1].
  • Xe – the position in the flat-earth frame, [3,1].
  • Wind – the wind angles [μ; γ; χ] in radians, [3,1].
  • DCMwe – the direction cosine matrix from the flat-earth frame to wind axes, [3,3].
  • Vw – the velocity in wind axes, [V; 0; 0], [3,1].
  • alpha_beta – [α; β] in radians, [2,1].
  • alpha_beta_dot – [α'; β'] in rad/s, [2,1].
  • wb – the body rates [p; q; r] in rad/s, [3,1].
  • wb_dot – the angular accelerations [p'; q'; r'] in rad/s², [3,1].
  • Ab – the acceleration in body axes, Vb × ω + DCMwbT·a with Vb = DCMwbT·[V; 0; 0], [3,1].

Parameters

  • Units – Metric (MKS) (the default) or English (velocity in ft/s). The two are the same arithmetic, so the choice only says which units the numbers are in.
  • Initial Position [Xe Ye Ze] – three values. Defaults to [0 0 0].
  • Initial Velocity [V alpha beta] – the initial airspeed, incidence and sideslip (radians), three values. Defaults to [0 0 0]; the airspeed divides, so a run needs a nonzero one.
  • Initial Wind Angles [mu gamma chi] – the initial bank, flight-path and heading angles in radians, three values, with |γ| below 90°. Defaults to [0 0 0].
  • Initial Body Rates [p q r] – in rad/s, three values. Defaults to [0 0 0].
  • Mass – m, a scalar > 0. Defaults to 1.
  • Inertia – the inertia tensor I in body axes, a [3,3] with a nonzero determinant. Defaults to eye(3).
  • Integration Substeps – M, how many fourth-order Runge-Kutta steps a sample is integrated with on the discrete solver and in exported code, a whole number of 1 or more. Defaults to 100. No Simulink counterpart.
  • Sampling Time (s) – zero or less inherits the solver's rate; a positive value runs the block at that period.

Code export

All ten targets: Python, MATLAB, Java, Rust, C, C++, VHDL, Verilog, SystemVerilog and PLC Structured Text. A core holds the twelve states, publishes the ten outputs from them and the current inputs, and integrates one sample with the inputs held and M Runge-Kutta substeps – with M = 100, the same computation as Simulink's fixed-step ode4 at one hundredth of the sample time. The mass and the inertia and its inverse are folded to constants.

The three HDL targets are simulation-only real arithmetic, quantized at the port: a sine of a state has no Q16.16 form. The cores simulate correctly and are not offered as synthesizable.

Simulink bridge

Import and export, mapped to Aerospace Blockset's aerolib6dof2/6DOF Wind (Wind Angles): Units → units (Metric (MKS) 1:1, English (velocity in ft/s) ↔ English (Velocity in ft/s)), Initial Position [Xe Ye Ze] → xme_0, Initial Velocity [V alpha beta] → Vm_0, Initial Wind Angles [mu gamma chi] → wind_0, Initial Body Rates [p q r] → pm_0, Mass → mass_0 and Inertia → inertia. Always emitted with mtype = Fixed, rep = Wind Angles and vre_flag and abi_flag off: each of those moves that block's port list, and this block has one. The knots unit system is not offered – it converts velocities inside the integration – and an imported one is reported. "Sampling Time (s)" does not cross: the Simulink block is continuous and defines no SampleTime.

Notes

  • Stateful, continuous and nonlinear: twelve continuous states. Three outputs – alpha_beta_dot, wb_dot and Ab – read the inputs, so the block has direct feedthrough, as the Simulink block does: a loop from those outputs back to F or M is an algebraic loop. The other seven are functions of the state alone.
  • The angular acceleration uses the transpose of the inertia's inverse, I−T, as the Simulink block does (it right-divides a row by I). For a symmetric inertia – any physical one – that is I−1; for an asymmetric matrix the two differ.
  • V = 0, β = ±90° and γ = ±90° are singular: the airspeed and cos β divide the incidence rates, and tan γ and 1/cos γ grow without bound in the wind-angle kinematics, in this block as in Simulink's.

Code facts#

FactValue
registered typeRobotics/Equations_Of_Motion/EOM_6DOF_Wind_Angles
familyRobotics/Equations_Of_Motion
solver environment classICoreBlock_0_Robotics_1_Equations_Of_Motion_2_EOM_6DOF_Wind_Angles
sourcesrc/ICoreBlocks/ICoreBlockLibrary/Blocks/Robotics/Equations_Of_Motion/EOM_6DOF_Wind_Angles/ICoreBlock_0_Robotics_1_Equations_Of_Motion_2_EOM_6DOF_Wind_Angles.cpp
headersrc/ICoreBlocks/ICoreBlockLibrary/Blocks/Robotics/Equations_Of_Motion/EOM_6DOF_Wind_Angles/ICoreBlock_0_Robotics_1_Equations_Of_Motion_2_EOM_6DOF_Wind_Angles.h
default size on canvas160 × 210 px
ports at insert2 in, 10 out
code generators implementedPython, MATLAB, Java, Rust, C, C++, VHDL, Verilog, SystemVerilog, PLC Structured Text

Ports#

#DirectionSignal typeDescription label
1inICoreDoubleF
2inICoreDoubleM
3outICoreDoubleVe
4outICoreDoubleXe
5outICoreDoubleWind
6outICoreDoubleDCMwe
7outICoreDoubleVw
8outICoreDoublealpha_beta
9outICoreDoublealpha_beta_dot
10outICoreDoublewb
11outICoreDoublewb_dot
12outICoreDoubleAb

Ports the constructor creates. A block whose port list changes with its configuration adds or removes ports at load time; the count above is the one a freshly inserted block has.

Configuration variables#

Config variableDefaultSimulink parameter
UnitsMetric (MKS)%~%English (velocity in ft/s)~~Metric (MKS)units
Initial Position [Xe Ye Ze][0 0 0]xme_0
Initial Velocity [V alpha beta][0 0 0]Vm_0
Initial Wind Angles [mu gamma chi][0 0 0]wind_0
Initial Body Rates [p q r][0 0 0]pm_0
Mass1.0mass_0
Inertia[1 0 0; 0 1 0; 0 0 1]inertia
Integration Substeps100not crossed

Every block also carries Sampling Time (s) from ICoreBlockSolverEnvironment: zero or less inherits the solver's rate, a positive value runs the block at that period.

supportSupport::Both
Simulink pathaerolib6dof2/6DOF Wind (Wind Angles)
port-count rulePortsParam::None
SampleTime parameterno — the counterpart defines none; the rate stays on the ICore side
deliberately not crossedIntegration Substeps
always setmtype = Fixed, rep = Wind Angles, vre_flag = off, abi_flag = off
ICore configSimulink parameterValue translation
UnitsunitsMetric (MKS) → Metric (MKS), English (velocity in ft/s) → English (Velocity in ft/s)
Initial Position [Xe Ye Ze]xme_0passes through
Initial Velocity [V alpha beta]Vm_0passes through
Initial Wind Angles [mu gamma chi]wind_0passes through
Initial Body Rates [p q r]pm_0passes through
Massmass_0passes through
Inertiainertiapasses through

Caveat (shown to the user): aerolib6dof2/6DOF Wind (Wind Angles) is continuous and has NO SampleTime parameter (verified against the R2026a block dialog). mtype, rep, vre_flag and abi_flag are pinned because each moves that block's port list; the kts unit system is not offered because it converts velocities inside the integration; "Integration Substeps" is how this block integrates a sample and has no counterpart

Catalog contract: src/ICoreBlocks/ICoreCoder/ICoreCommandSystem/SimulinkBridge/ICoreSimulinkBlockCatalog.h

Description vs code#

The checker has a blind spot here — it could not resolve something (a grouped port bullet, a computed config name), which is reported and never counted as a pass. A reader has to settle it:

  • B0 every stimulus in the sample errored — cross-checks skipped

The verdict above is tools/docs/check_block_descriptions.py (P7.1), which compares LISTS. It cannot read a sentence: "stateless" on a block with a state, an initial-value semantic the recursion does not implement, a "not synthesizable" caveat the HDL banner contradicts. That is the agent audit (P7.3) on BLOCK_DESCRIPTION_AUDIT.md, and this tool's green is not a substitute for one.

File banner (developer view)#

The top comment of the block's .cpp — the maths, the realization and the export strategy, addressed to whoever changes it. It must not contradict the description above (P7.5).

6DOF Wind (Wind Angles) -- rigid-body equations of motion in wind axes, fixed mass State [V alpha beta, mu gamma chi, p q r, xe ye ze]; inputs F ([3,1], WIND axes) and M ([3,1], body axes). The equations, and the measurement that settled each of them against R2026a's aerolib6dof2/6DOF Wind (Wind Angles), are in ICoreEomWindAnglesSupport.cpp's banner, shared with the two variable-mass blocks. What this block adds:

  • Ten outputs, in the order Ve, Xe, [mu gamma chi], DCM_we [3,3], Vw, [alpha beta],

[alpha' beta'], [p q r], [p' q' r'], Ab (measured from the mask's Outport list). The last three read the inputs, so the block has DIRECT FEEDTHROUGH.

  • The initial state is Vm_0 = [V alpha beta], wind_0 = [mu gamma chi], pm_0 and xme_0 as

given; the mass and inertia are the dialog's constants (mass_0, inertia).

  • "Metric (MKS)" and "English (Velocity in ft/s)" are the same arithmetic (no gravity inside);

kts is not offered (it converts velocities inside the integration). mtype, rep, vre_flag and abi_flag each move the Simulink port list; pinned.

The inertia's inverse is folded to constants at export (adjugate over determinant), where the mask right-divides each step; the two agree to rounding. A continuous block with a real derivative; the discrete path and every exported core run ICoreEomRk4's map, which at M = 100 substeps is Simulink's fixed-step ode4 at Ts/100. ⚠ V = 0, beta = +/-90 deg and gamma = +/-90 deg are singular, exactly as in Simulink.

Sample results#

No stimulus produced a sampled output in this rig — Invalid input size at EOM 6DOF Wind Angles block: ICore Blocks/Home/EOM 6DOF Wind Angles. That is a fact about the single-block rig, not a verdict on the block: an offline batch fit, a block whose output only appears at onSolverFinish, or one that needs a driven environment cannot be exercised alone.

Category unsampled · sample time 0.1 · 60 steps · commit ae1a5a4f23bf9080195613e8ad1f6128ae5da42d · produced by docsSample --out <folder> --blocks Turbofan_Engine_System EOM_6DOF_Wind_Angles EOM_6DOF_Custom_Variable_Mass_Wind_Angles EOM_6DOF_Simple_Variable_Mass_Wind_Angles Surface_Fit Smoothing_Spline Thin_Plate_Spline LPC_To_LSF_LSP --steps 60

Sample data: docs/generated/samples/Robotics__Equations_Of_Motion__EOM_6DOF_Wind_Angles.json