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#
| Fact | Value |
|---|---|
| registered type | Robotics/Equations_Of_Motion/EOM_6DOF_Wind_Angles |
| family | Robotics/Equations_Of_Motion |
| solver environment class | ICoreBlock_0_Robotics_1_Equations_Of_Motion_2_EOM_6DOF_Wind_Angles |
| source | src/ICoreBlocks/ICoreBlockLibrary/Blocks/Robotics/Equations_Of_Motion/EOM_6DOF_Wind_Angles/ICoreBlock_0_Robotics_1_Equations_Of_Motion_2_EOM_6DOF_Wind_Angles.cpp |
| header | src/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 canvas | 160 × 210 px |
| ports at insert | 2 in, 10 out |
| code generators implemented | Python, MATLAB, Java, Rust, C, C++, VHDL, Verilog, SystemVerilog, PLC Structured Text |
Ports#
| # | Direction | Signal type | Description label |
|---|---|---|---|
| 1 | in | ICoreDouble | F |
| 2 | in | ICoreDouble | M |
| 3 | out | ICoreDouble | Ve |
| 4 | out | ICoreDouble | Xe |
| 5 | out | ICoreDouble | Wind |
| 6 | out | ICoreDouble | DCMwe |
| 7 | out | ICoreDouble | Vw |
| 8 | out | ICoreDouble | alpha_beta |
| 9 | out | ICoreDouble | alpha_beta_dot |
| 10 | out | ICoreDouble | wb |
| 11 | out | ICoreDouble | wb_dot |
| 12 | out | ICoreDouble | Ab |
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 variable | Default | Simulink parameter |
|---|---|---|
Units | Metric (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 |
Mass | 1.0 | mass_0 |
Inertia | [1 0 0; 0 1 0; 0 0 1] | inertia |
Integration Substeps | 100 | not 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.
Simulink bridge#
| support | Support::Both |
| Simulink path | aerolib6dof2/6DOF Wind (Wind Angles) |
| port-count rule | PortsParam::None |
SampleTime parameter | no — the counterpart defines none; the rate stays on the ICore side |
| deliberately not crossed | Integration Substeps |
| always set | mtype = Fixed, rep = Wind Angles, vre_flag = off, abi_flag = off |
| ICore config | Simulink parameter | Value translation |
|---|---|---|
Units | units | Metric (MKS) → Metric (MKS), English (velocity in ft/s) → English (Velocity in ft/s) |
Initial Position [Xe Ye Ze] | xme_0 | passes through |
Initial Velocity [V alpha beta] | Vm_0 | passes through |
Initial Wind Angles [mu gamma chi] | wind_0 | passes through |
Initial Body Rates [p q r] | pm_0 | passes through |
Mass | mass_0 | passes through |
Inertia | inertia | passes 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:
B0every 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