Skip to content

Chapter 4: Vehicle Motion Modeling and Simulation

Whether for the validation of new aircraft development or theoretical pre-exploration under extreme operational conditions, an accurate vehicle dynamics model remains the most critical bridge between low-level control and high-level AI systems. This chapter focuses on constructing multi-form dynamics models—from rotorcraft to unmanned ground/sea vehicles—based on MATLAB/Simulink and the RflySim toolbox, ultimately exporting cross-ecosystem-validated DLL hot-swappable asset packages.

4.1 Background and Theory

Precise mathematical and physical analysis forms the fidelity lower bound for simulation systems. Vehicle modeling involves not only solving six-degree-of-freedom spatial differential equations at the rigid-body mechanics level (including mass distribution inertia tensor, gravity characteristics, translation, and rotation matrices), but also encompasses powerplant and actuator model evaluations (e.g., nonlinear fitting laws for propeller thrust and torque under extreme flow fields in aerodynamics, as well as disturbance characteristics of aerodynamic control surfaces under varying angles of attack).

Beyond the structural vehicle itself, stochastic simulation of environmental and sensor systems—such as geomagnetic field vector models at different latitudes and longitudes, barometric altitude errors caused by temperature gradients, and GNSS Gaussian-Markov noise—is equally vital to motion modeling. Only by fully integrating these mathematical principles can it be termed "true-to-life environment simulation."

alt text

4.2 Framework and Interfaces

Within RflySim's product matrix, vehicle models are not only executed as mathematical formulas but also packaged as plug-and-play digital base interfaces with hot-swappable capability, thereby fully enabling seamless testing across software-in-the-loop and physical flight vehicle validation.

alt text

4.2.1 CopterSim Model Loading Architecture

For standard quadcopters or octocopters, the CopterSim platform already embeds a highly optimized dynamics solver at the low level (default operating based on a set of standardized rotor aerodynamic coefficient equations), capable of millisecond-level rigid-body attitude updates. By simply loading via the GUI or configuring simple XML configuration data through command-line parameters, users can simulate body scaling and conventional parameter variations without rewriting source code.

alt text

For special, non-standard configurations—such as tiltrotors, ornithopters, or even large airships—one can fully leverage MATLAB/Simulink's graphical flowchart modules to construct the underlying power flow. Within this ecosystem, the platform exposes a set of low-level sensor noise generators and chassis motion equation input interfaces, allowing users to freely assemble vehicle characteristics with full proprietary intellectual property rights.

To facilitate researchers outside the MATLAB environment and performing rapid distributed computation validation on low-performance machines, the toolbox supports one-click compilation of the aforementioned Simulink models into Windows dynamic link libraries (.dll). These DLLs seamlessly integrate into CopterSim or even RflySim3D scenes as drive kernels, with support for code encryption protection.

4.3 Showcase of Representative Cases

4.4 Course-Linked Video Lectures

Public Lecture Replay for This Chapter (Session 4: Vehicle Motion Modeling and Simulation):

4.5 Chapter Experiment Cases

The verification experiments and guided cases related to this chapter are located in the [Installation Directory]\RflySimAPIs\4.RflySimModel folder.

1.5.1 Interface Learning Experiments

Located in the 4.RflySimModel\0.ApiExps folder, covering foundational interface tutorials for the platform and general introductions to various tools.

Experiment 1: Vehicle Motion Modeling and Simulation Interface

📝 Experiment Overview:
Learn the RflySim platform's vehicle motion modeling, software/hardware-in-the-loop simulation workflow, and a quick-start guide to the UDP communication interface.

Experiment 2: Simulink Calling C Code Experiment

📝 Experiment Overview:
Introduce five methods for calling external C code in Simulink models, including MATLAB Function, DLL, S-Function Builder, Stateflow Charts, and C Caller module calls, to improve simulation efficiency and code reuse.

Experiment 3: ExtCtrlAPI-UDP20100

📝 Experiment Overview:
Receive PX4 state estimation values via UDP port 20101, implementing an external communication interface experiment in software/hardware-in-the-loop simulation.

Experiment 4: Using the InFloatsCollision Collision Model Port

📝 Experiment Overview:
Learn to use the inFloatsCollision interface in the RflySim platform's maximum model, implement physics engine collision functionality via UDP data, and verify the bounce or stay effect of a UAV after colliding with an obstacle.

Experiment 5: inSILIntsFloats Interface Experiment

📝 Experiment Overview:
Learn to simultaneously inject integer flags and floating-point parameters into the DLL model via the inSILIntsFloats interface, enabling external fault injection, event triggering, and state linkage functionality.

Experiment 6: DLL Model External Loading Interface Demonstration Experiment

📝 Experiment Overview:
Learn how to load and invoke a DLL comprehensive model via an external program, using the Python interface to control a quadcopter model for takeoff and flight in RflySim 3D.

Experiment 7: Multi-Model Control Initialization Position and Attitude Experiment

📝 Experiment Overview:
Set the initial altitude, roll angle, pitch angle, and yaw angle of a quadcopter via a bat script, supporting position and attitude initialization for single and multiple UAVs in software-in-the-loop and hardware-in-the-loop simulations.

Experiment 8: PX4 Hardware-in-the-Loop Simulation Communication Experiment

📝 Experiment Overview:
Test the integration of the PX4 flight control system with the physical model through hardware-in-the-loop (HITL) simulation, verify the collaborative work of the flight controller and dynamics model, and support precise flight control and simulation verification.

Experiment 9: PX4 State Flag Experiment

📝 Experiment Overview:
Observe the changes in PX4 state flags via the inCopterData(5) interface when a VTOL UAV model switches between rotor and fixed-wing modes, mastering the usage of this input interface.

Experiment 10: Using the ReqCopterSim Interface Library

📝 Experiment Overview:
Learn to set CopterSim initialization parameters via the Python interface ReqCopterSim.py, including online mode, position, attitude, DLL model, and 3D scene, mastering the simulation initialization configuration method.

Experiment 11: InFloatsCollision Collision Interface Verification

📝 Experiment Overview:
Verify RflySim 3D collision detection and response functionality via the InFloatsCollision interface, implementing a quadcopter model collision test experiment.

Experiment 12: sendSILIntDouble Interface Experiment

📝 Experiment Overview:
Learn to use the Python interface sendSILIntDouble() to send double-type data to the inDoubCtrls port of the RflySim platform's DLL model, mastering the invocation method of the external input interface.

Experiment 13: Using the sendSILIntDouble Interface

📝 Experiment Overview:
Learn to use Python's sendSILIntDouble() interface to input 28-dimensional double-type data to the inSIL28d model of the RflySim platform, and perform software-in-the-loop simulation verification via CopterSim.

Experiment 14: InCollisionAPI Collision Interface Experiment

📝 Experiment Overview:
Learn how to input RflySim 3D collision results into the DLL model, implementing functions such as collision detection, collision force feedback, and post-collision fault triggering.

Experiment 15: Series of Experiments on Extending External Data Input Interfaces for DLL Models

📝 Experiment Overview:
Learn how to inject extended external data into the DLL model, covering three typical input interfaces: inSILIntsFloats, inDoubCtrls, and inSIL28d, used for fault injection, parameter passing, custom control input, and data link verification.

Experiment 16: External Loading and Invocation Interface for DLL Comprehensive Models

📝 Experiment Overview:
Learn how to externally load a comprehensive model DLL from Python or Simulink, complete vehicle creation, state update, external control, and multi-vehicle scheduling, providing an entry point for secondary development and rapid joint debugging of comprehensive models.

Experiment 17: PX4 Model-in-the-Loop Simulation (SIH)

📝 Experiment Overview:
This experiment summarizes the three working modes of PX4 Model-in-the-Loop (SIH) (SIH_COM, SIH_FLY, SIH_SITL), helping users verify the collaborative work of flight control algorithms and dynamics models according to different joint debugging scenarios.

Experiment 18: DLL Model External Communication Experiment - Reading Simulation Ground Truth Data

📝 Experiment Overview:
Read real data from CopterSim flight simulation in software/hardware-in-the-loop simulation by listening to UDP 30101 series ports, learning UDP communication principles and packet structure.

Experiment 19: Automatic C/C++ Code Generation from Simulink Models

📝 Experiment Overview:
Based on Embedded Coder, guide users through the process of automatically generating C/C++ code from Simulink models, including model building, parameter setting, solver configuration, and code generation.

Experiment 20: inSILIntsFloats External Data Input Interface Experiment

📝 Experiment Overview:
Learn to use the inSILInts and inSILFloats interfaces in the RflySim platform's maximum system model, implementing fault injection functionality by receiving external structure data via UDP.

Experiment 21: DLL Model Loading and Accelerated Simulation

📝 Experiment Overview:
Learn to load and invoke a DLL comprehensive model via an external program to achieve accelerated simulation, mastering the usage of the DllSimCtrlAPI.ModelLoad interface.

Experiment 22: PX4_SIH_FLY Simulation Experiment

📝 Experiment Overview:
Run an improved software-in-the-loop SIH model via the RflySim platform, explore the collaborative mechanism of the PX4 flight control algorithm and the built-in dynamics model, and verify the performance of the flight control algorithm in the simulation environment under SIH mode.

Experiment 23: RC Channel Signal Experiment

📝 Experiment Overview:
Receive remote control channel signals via dimensions 9-24 of the inCopterData interface, connect to the 3D display interface in the Simulink model, implement hardware-in-the-loop simulation, and observe the state changes of each remote control channel in real time.

Experiment 24: UUV Initial Position and Attitude Setting

📝 Experiment Overview:
Set the initial depth, roll angle, pitch angle, and yaw angle of an underwater vehicle via a bat script, supporting software-in-the-loop and hardware-in-the-loop simulations, enabling initial position and attitude setting for single and multiple unmanned vehicles.

Experiment 25: User-Defined C++ Code Generation and Invocation

📝 Experiment Overview:
This experiment introduces how to convert custom Simulink models into C/C++ code and how to call existing C code in Simulink, laying the foundation for DLL model construction and embedded deployment.

Experiment 26: Using the inCollision20d Collision Engine Interface

📝 Experiment Overview:
Introduce the usage of the newly added inCollision20d model input interface on the RflySim platform. Through DLL model generation and software-in-the-loop simulation experiments, implement quadcopter collision detection and collision response in physics engine mode.

Experiment 27: Sending 28-Dimensional Double Data via the inDoubCtrls Interface

📝 Experiment Overview:
This experiment explains how to send 28-dimensional double-type data to the DLL model via the inDoubCtrls interface, enabling unified input of continuous control quantities, custom state quantities, or external parameters.

Experiment 28: inFloatsCollisionApi Collision Detection API Experiment

📝 Experiment Overview:
Through the quadcopter model collision detection module, learn to add and use collision detection functionality in SITL and HITL modes, observing the impact of collisions on flight performance.

Experiment 29: sendInDoubCtrls Interface Experiment

📝 Experiment Overview:
Learn to use Python's sendInDoubCtrls() interface to send data to the 28-dimensional double-type input port of the RflySim platform's DLL model, and verify data transmission via a Simulink monitoring program.

Experiment 30: sendInDoubCtrls Interface Experiment

📝 Experiment Overview:
Learn to use Python's sendInDoubCtrls() function to send 28-dimensional double-type data to the inSIL28d interface of the RflySim platform, implementing external control input in software-in-the-loop simulation.

Experiment 31: CopterSimSILNoPX4 Comprehensive Model Initialization and Control

📝 Experiment Overview:
Through the DLL model and UDP commands, initialize a quadcopter comprehensive model in the air and directly perform mission control, learning software-in-the-loop simulation and multi-vehicle control.

Experiment 32: External Control UDP Communication Experiment

📝 Experiment Overview:
Learn to exchange state estimation values, ground truth data, and custom messages between the DLL model, CopterSim, RflySim 3D, and external control programs via UDP ports, providing a foundation for external control and protocol extension.

Experiment 33: ExtCtrlAPI-UDP40100

📝 Experiment Overview:
Receive rfly_px4 uORB messages via UDP 40101 series ports, implement an external control interface experiment, and learn UDP communication protocols and hardware-in-the-loop simulation.

Experiment 34: DLL Comprehensive Model Extended External Loading Interface Demonstration Experiment

📝 Experiment Overview:
By inheriting the ModelLoad class, implement external program loading and invocation of the DLL comprehensive model, simplifying the initialization steps and supporting custom control methods.

Experiment 35: PX4 SIH SITL Model Software-in-the-Loop Simulation Experiment

📝 Experiment Overview:
Learn and verify the PX4 official SIH model-in-the-loop simulation mode. By integrating flight control logic with a simplified dynamics model, achieve closed-loop simulation without an external physics engine, and use CopterSim and RflySim 3D for visualization and mission verification.

Experiment 36: Collision Detection and Motor Fault Simulation Experiment

📝 Experiment Overview:
Through the quadcopter model collision detection and motor fault triggering module, learn to perform software-in-the-loop simulation in RflySim, implementing a simulation workflow where two aircraft collide, causing motor damage and crashing.

Experiment 37: inSIL28d Interface Invocation Experiment

📝 Experiment Overview:
This experiment explains how to send 28-dimensional double-type extended input to the DLL model via the inSIL28d interface, and verify the usage of this interface in log replay and model joint debugging using Python and Simulink.

Experiment 38: inSILInts and inSILFloats Interface Invocation Experiment (Python)

📝 Experiment Overview:
Demonstrate the usage of the inSILInts and inSILFloats input interfaces in the RflySim model via a Python program, implementing dynamic modification of the 3D display model.

Experiment 39: rfly_px4 uORB Message Experiment

📝 Experiment Overview:
Listen to rfly_px4 uORB messages via the inCopterData input interface, learn to send and receive custom messages, and display data in real time on the UE interface and in Simulink.

Experiment 40: RflySim Model Initialization Settings

📝 Experiment Overview:
Learn to reset the simulation initial state of the DLL model via a Python interface or bat script, including parameters such as online mode, return IP, vehicle pose, and UDP communication mode.

Experiment 41: DLL Model Manual Loading and Update Experiment

📝 Experiment Overview:
Load and invoke a DLL comprehensive model via an external program, manually set the span to update the model state, achieve high-speed simulation, and learn the usage of the ModelLoad and ModelUpdate interfaces.

Experiment 42: DLL Comprehensive Model Automatic Update Interface Experiment

📝 Experiment Overview:
Learn to load and invoke a DLL comprehensive model via an external program, using the ModelLoad interface class to implement model initialization, automatic state update, and external control.

Experiment 43: ExtToUE4 Interface Custom Data Experiment

📝 Experiment Overview:
Learn how to customize data sent to the ExtToUE4 interface of the maximum model, generate a DLL via Simulink model compilation, and verify data transmission in software-in-the-loop simulation to drive the 3D engine to display complex motion states.

Experiment 44: DLL Model Loading and Simulink External Control Experiment

📝 Experiment Overview:
Load a DLL comprehensive model via Python and start external control, use a Simulink program to execute a trajectory tracking task, and learn the usage of DLL model loading and external control interfaces.

Experiment 45: ExtToPX4 Interface Custom Data Sending Experiment

📝 Experiment Overview:
Learn how to customize and send data to the PX4 flight controller's uORB message rfly_ext via the ExtToPX4 interface, enabling the transmission of sensor or other necessary data for model development and debugging.

Experiment 46: DLL Model Python External Multi-Vehicle Control Experiment

📝 Experiment Overview:
Load multiple DLL comprehensive models via a Python external program to implement multi-UAV flight mission control, learning the usage of DllSimCtrlAPI and Mavlink communication interfaces.

Experiment 47: DLL Comprehensive Model Python External Control Experiment

📝 Experiment Overview:
Learn how to externally load a DLL comprehensive model via a Python program and use port 30100 for external control to execute flight missions.

Experiment 48: OutCopterData Custom Output Interface Verification

📝 Experiment Overview:
Learn how to use the outCopterData interface in the maximum system model to customize and record 32-dimensional data during the simulation process, and understand the data recording and UDP transmission mechanism.

Experiment 49: CopterSim Loading DLL Comprehensive Model Python External Control

📝 Experiment Overview:
Learn to use CopterSim to load and invoke a DLL comprehensive model, control flight missions via an external Python program, and master simulation environment configuration and Python API control interfaces.

Experiment 50: inCopterData Flight Controller Data Input Interface

📝 Experiment Overview:
Input PX4 state flags, remote control channel signals, and custom rfly_px4 messages into the DLL model via the inCopterData interface, achieving deep linkage between the model and the flight controller.

1.5.2 Basic Usage Experiments

Stored in the 4.RflySimModel\1.BasicExps folder, providing a complete set of supplementary teaching materials for beginners.

Experiment 1: MBD Introductory Experiment

📝 Experiment Overview:
Introduce the fundamentals of unmanned vehicle system modeling, including vehicle classification, assembly overview, unified modeling framework, and reference coordinate systems, laying the theoretical foundation for subsequent model-based development (MBD) experiments.

Experiment 2: Introduction to the Minimal Template

📝 Experiment Overview:
Introduce how to use the RflySim platform’s minimal template for software-in-the-loop and hardware-in-the-loop simulation, including DLL model generation, simulation startup, and result observation.

Experiment 3: Minimal Model Template Library Usage

📝 Experiment Overview:
Using a multirotor model as an example, introduce how to use the platform’s minimal template for software/hardware-in-the-loop simulation, including DLL model generation, SITL, and HITL simulation steps.

Experiment 4: Fixed-Wing Model Control

📝 Experiment Overview:
Learn software-in-the-loop and hardware-in-the-loop simulation of fixed-wing models via the RflySim platform, mastering the basic dynamics characteristics and waypoint planning operations of fixed-wing UAVs.

Experiment 5: Ackermann Chassis UGV Model Control

📝 Experiment Overview:
Learn to compile a Simulink model into a DLL model file for an Ackermann chassis UGV, and perform software/hardware-in-the-loop simulation tests under the PX4 controller, becoming familiar with the use of the Ackermann chassis UGV model.

Experiment 6: Differential Drive UGV Model Control

📝 Experiment Overview:
Learn to compile Simulink files to generate a DLL model file for a differential drive UGV, and perform software/hardware-in-the-loop simulation tests under the official PX4 controller, becoming familiar with the use of the differential drive UGV model.

Experiment 7: Micro Fixed-Wing Model Modeling and Simulation

📝 Experiment Overview:
Understand the modeling principles of micro fixed-wing models. Through this example, become familiar with the use of the platform’s micro fixed-wing model, including DLL model generation, software-in-the-loop simulation, and hardware-in-the-loop simulation.

1.5.3 Advanced Development Experiments

Stored in the 4.RflySimModel\2.AdvExps folder, these experiments further familiarize users with certain low-level firmware ecosystem configurations.

Experiment 1: Introduction to the Maximum Template

📝 Experiment Overview: Introduce how to use the RflySim platform's maximum template for software-in-the-loop and hardware-in-the-loop simulation, including steps such as model compilation, DLL generation, simulation startup, and result observation.

Experiment 2: Closed-Loop Verification of Multirotor Models

📝 Experiment Overview: Conduct closed-loop verification of multirotor models based on the system template, covering scenarios such as quadcopter, hexacopter, octocopter, compound multirotor, tethered UAV, and comprehensive model external control, while introducing collision detection and system identification model validation.

Experiment 3: Closed-Loop Verification of Fixed-Wing Models

📝 Experiment Overview: Based on the fixed-wing minimum template, conduct complex closed-loop verification experiments including collision detection, waypoint control, attitude control, speed/altitude/yaw control, comprehensive model simulation, and parameter adaptation.

Experiment 4: VTOL Model and Control Experiment

📝 Experiment Overview: Validate the software/hardware-in-the-loop simulation workflow for standard VTOL aircraft and tail-sitter VTOL UAVs, supplemented with experiments on flight mode switching.

Experiment 5: Ackermann Chassis UGV Control Experiment

📝 Experiment Overview: Validate the position and velocity control capabilities of the Ackermann chassis UGV model in software/hardware-in-the-loop scenarios, and compare Python and Matlab/Simulink external control methods.

Experiment 6: Differential Drive UGV Differential Control Experiment

📝 Experiment Overview: Validate the position and velocity control capabilities of the differential drive UGV model in software/hardware-in-the-loop scenarios, comparing Python and Matlab/Simulink external control methods.

Experiment 7: Closed-Loop Verification of High-Precision Trailer Model

📝 Experiment Overview: This experiment validates the software/hardware-in-the-loop simulation workflow for high-precision trailer models and comprehensive UGV models, helping users master DLL generation, control loop closure, and external control verification methods for refined vehicle models.

Experiment 8: Helicopter Model Experiment

📝 Experiment Overview: Validate the operational performance of the helicopter model in software/hardware-in-the-loop and Offboard external control scenarios, covering basic integration, position control, and velocity control experiments.

Experiment 9: Differential USV Model Validation Based on System Template

📝 Experiment Overview: Learn to import the generated USV model into the RflySim platform for software/hardware-in-the-loop simulation testing, becoming familiar with USV model usage and waypoint mission execution through SIL/HIL experiments.

Experiment 10: UUV Model Closed-Loop Verification

📝 Experiment Overview: Summarizes three typical experiments for underwater unmanned vehicle models: hardware-in-the-loop, software-in-the-loop, and underwater VINS fusion positioning, helping users master the operation, control, and positioning verification methods of UUV models in RflySim.

Experiment 11: Flying Wing Model DLL Generation and SIL/HIL Experiment

📝 Experiment Overview: Validation of a flying-wing UAV model based on the system template, including DLL model generation, software-in-the-loop simulation, and hardware-in-the-loop simulation, learning flying-wing dynamics modeling and PX4 software/hardware-in-the-loop testing.

Experiment 12: Multirotor Power System Identification Experiment

📝 Experiment Overview: Complete the full workflow of multirotor power system identification, from test preparation and static thrust measurement to static/dynamic power model identification, establishing the quantitative relationship between motor PWM input and propeller thrust and counter-torque.

Experiment 13: Multirotor Full-Vehicle Modeling Framework and Parameter Identification Experiment

📝 Experiment Overview: This experiment focuses on parameter acquisition and template construction for the multirotor full-vehicle model, covering wind resistance identification, drag torque and moment of inertia measurement, six-degree-of-freedom modular modeling, and power sub-model integration validation, providing a foundation for forming a high-precision full-vehicle model capable of closed-loop validation.

Experiment 14: Multirotor Full-Vehicle System Identification and Model Validation

📝 Experiment Overview: This experiment uses the MATLAB System Identification Toolbox and hardware-in-the-loop frequency sweep identification to estimate the dynamic models of the multirotor's roll, pitch, and yaw channels from experimental data, and validates the model quality.

Experiment 15: Ackermann UGV Position Control (Python)

📝 Experiment Overview: Implement position control for single/multiple Ackermann chassis UGVs in software/hardware-in-the-loop simulation mode using the Python platform position control interface, learning UGV control methods based on the RflySim toolchain.

Experiment 16: Differential Drive UGV Model Validation (Python Position Control)

📝 Experiment Overview: Implement position control for single/multiple UGVs in software/hardware-in-the-loop simulation mode using the Python platform position control interface, learning the use of the RflySim toolchain and differential drive UGV model validation.

Experiment 17: Fixed-Wing Model Collision Detection DLL Generation and SIL/HIL Experiment

📝 Experiment Overview: Learn to compile and generate a fixed-wing DLL model file in Matlab, and conduct software-in-the-loop and hardware-in-the-loop simulation tests to validate the fixed-wing UAV model with collision detection.

Experiment 18: Helicopter Model Software/Hardware-in-the-Loop Simulation

📝 Experiment Overview: Become familiar with the simulation operation steps for the helicopter model through software-in-the-loop and hardware-in-the-loop simulation, including parameter configuration, waypoint mission upload, and remote controller control.

Experiment 19: Using the MATLAB System Identification Toolbox

📝 Experiment Overview: Become familiar with the MATLAB System Identification Toolbox, learn data preprocessing methods, and perform model estimation and validation based on datasets.

Experiment 20: Multi-Model Control Experiment

📝 Experiment Overview: Compile and generate a quadcopter DLL model file, and conduct software-in-the-loop and hardware-in-the-loop simulation tests to learn quadcopter model generation and validation methods.

Experiment 21: Power System Static Thrust Test Bench Installation and Use

📝 Experiment Overview: Learn the basic functions, installation steps, and supporting software tools of the multirotor power system static thrust test bench, mastering power unit installation and data acquisition methods.

Experiment 22: Multirotor Power System Static Thrust Model Test

📝 Experiment Overview: Learn to use the power system comprehensive test bench to test and record static thrust and torque data of the multirotor power system under different PWM inputs, providing experimental data for subsequent modeling.

Experiment 23: TrailerModelCtrl

📝 Experiment Overview: Test the refined UGV DLL model through software/hardware-in-the-loop simulation, learning the use and simulation workflow of the UGV model.

Experiment 24: UUV Hardware-in-the-Loop Simulation

📝 Experiment Overview: Use a remote controller to operate the UUV model through hardware-in-the-loop simulation, mastering the use of the UUV model, including three main steps: flight controller configuration, remote controller configuration, and hardware-in-the-loop simulation.

Experiment 25: VTOL Model Control Software/Hardware-in-the-Loop Simulation

📝 Experiment Overview: Use the standard VTOL aircraft DLL model compiled with Simulink to conduct software-in-the-loop (SIL) and hardware-in-the-loop (HIL) simulation tests, becoming familiar with the VTOL aircraft simulation workflow and dynamic characteristics.

Experiment 26: Wind Tunnel Drag Measurement and Identification

📝 Experiment Overview: Measure the aerodynamic drag of a multirotor UAV in fixed-attitude flight through wind tunnel experiments, identify drag coefficients using three-axis force sensor and wind speed data, learning wind resistance measurement and data processing methods.

Experiment 27: Hexacopter Comprehensive Model External Control

📝 Experiment Overview: Design a hexacopter controller and dynamics model based on MATLAB/Simulink to form a comprehensive model, achieving position, velocity, and yaw angle control through external control, learning the four-cascade PID controller and external control methods.

Experiment 28: Quad-Axis Octocopter Comprehensive Model External Control

📝 Experiment Overview: Design a quad-axis octocopter controller and dynamics model based on MATLAB/Simulink to form a comprehensive simulation closed loop, achieving position, velocity, and yaw angle control through external control.

Experiment 29: Octocopter Comprehensive Model External Control

📝 Experiment Overview: Design an octocopter controller and dynamics model based on MATLAB/Simulink to form a comprehensive model, using external control methods to achieve arming/takeoff, position and yaw angle control, velocity and yaw angle control, etc.

Experiment 30: Compound Multirotor Comprehensive Model External Control

📝 Experiment Overview: Control the compound multirotor comprehensive model via Matlab UDP, achieving switching and external control of quadcopter, hexacopter, octocopter, and quad-axis octocopter configurations.

Experiment 31: Compound Multirotor Comprehensive Model Python External Control

📝 Experiment Overview: Control the compound multirotor comprehensive model via Python UDP, achieving switching and simulation control of four models: quadcopter, hexacopter, octocopter, and quad-axis octocopter.

Experiment 32: Tethered UAV Model Simulation Test

📝 Experiment Overview: Validate the dynamic effects and control behavior of a UAV connected to a ground anchor point via a tether on the RflySim/CopterSim platform, demonstrating software/hardware-in-the-loop simulation using a tether model DLL.

Experiment 33: CarAckermanPosCtrl_Mat

📝 Experiment Overview: Use Matlab/Simulink to control the position of single/multiple UGVs in software/hardware-in-the-loop simulation mode, implementing position control experiments.

Experiment 34: Differential Drive UGV Position Control (Matlab)

📝 Experiment Overview: Use Matlab through the platform position control interface to control the position of multiple UGVs in software/hardware-in-the-loop simulation mode, learning the use of external control interfaces.

Experiment 35: Fixed-Wing Position Control API

📝 Experiment Overview: Use the RflySim platform fixed-wing position control interface to achieve fixed-wing UAV flight along desired waypoints in software/hardware-in-the-loop simulation, learning Python external control and simulation workflows.

Experiment 36: Multirotor Hardware-in-the-Loop Frequency Sweep Identification Experiment

📝 Experiment Overview: Perform attitude loop frequency sweep identification on a multirotor nonlinear model through hardware-in-the-loop simulation, obtaining transfer functions for the roll, pitch, and yaw channels, learning system identification and modeling methods.

Experiment 37: Helicopter Position Control Experiment

📝 Experiment Overview: Implement helicopter Offboard position control via the Python interface, including takeoff, position control, and cruise speed control, supporting software-in-the-loop and hardware-in-the-loop simulation.

Experiment 38: Multirotor Drag Torque Coefficient and Moment of Inertia Measurement and Identification

📝 Experiment Overview: Measure the UAV's moment of inertia using the bifilar pendulum method, and identify the pitch, roll, and yaw drag torque coefficients from angular velocity data collected by the flight controller, learning the calculation method for the damping coefficient of simple harmonic oscillation.

Experiment 39: Multi-Model Control Collision Detection Experiment

📝 Experiment Overview: Validation of a quadcopter model with collision detection based on the system template, compiling and generating a DLL model file via Simulink, and conducting software/hardware-in-the-loop simulation tests to learn the use of collision detection functionality.

Experiment 40: Static Thrust Integrated Model Identification Experiment

📝 Experiment Overview: Identify static and dynamic power integrated models through the quantitative relationship from motor throttle/PWM input to propeller thrust and counter-torque output, learning data import, unit unification, model fitting, and frequency domain identification methods.

Experiment 41: TailsitterModelCtrl

📝 Experiment Overview: Introduce how to use the platform's quadcopter tail-sitter VTOL UAV for software/hardware-in-the-loop simulation, observing the UAV's flight process in rotor and fixed-wing modes by uploading waypoint missions.

Experiment 42: TrailerNoPX4 UGV Comprehensive Model External Control

📝 Experiment Overview: Design a UGV controller based on MATLAB/Simulink, forming a comprehensive model with the DLL model, and send desired position and velocity commands through external control methods to achieve UGV simulation closed-loop control.

Experiment 43: UUV Software-in-the-Loop Simulation

📝 Experiment Overview: Use the UUV model compiled and generated by Simulink to validate basic path control algorithms through software-in-the-loop simulation, learning underwater robot simulation and path planning.

Experiment 44: Introduction to Small Wind Tunnel Equipment Use

📝 Experiment Overview: Understand the basic functions of the multirotor power system dynamic thrust test device and the composition of a small wind tunnel, learning experimental steps such as wind tunnel operation, pitot tube and airspeed sensor connection, and power test bench installation.

Experiment 45: Ackermann Chassis UGV Velocity Control (Python)

📝 Experiment Overview: Based on the RflySim platform, use the Python velocity control interface to achieve velocity control of single/multiple UGVs in software/hardware-in-the-loop simulation, learning the Ackermann chassis model and external control methods.

Experiment 46: Differential Drive UGV Model Validation (Python Velocity Control)

📝 Experiment Overview: Based on the RflySim platform, use the Python velocity control interface to achieve velocity control of single/multiple UGVs in software/hardware-in-the-loop simulation mode, learning differential drive UGV model validation methods.

Experiment 47: CopterSimSILNoPX4

📝 Experiment Overview: Design a quadcopter controller based on Simulink, forming a comprehensive model with the DLL model, achieving software-in-the-loop simulation through external control, learning PID control and external control methods.

Experiment 48: Fixed-Wing Attitude Angle Control

📝 Experiment Overview: Use the RflySim platform fixed-wing control interface to achieve attitude control experiments for single or multiple fixed-wing UAVs flying forward at a fixed 10° pitch angle, covering software-in-the-loop and hardware-in-the-loop simulation.

Experiment 49: Helicopter Velocity Control

📝 Experiment Overview: Implement circular flight using the helicopter Offboard velocity control interface via a Python program, becoming familiar with the software/hardware-in-the-loop simulation workflow and helicopter control channel mapping.

Experiment 50: Modular Construction of Quadcopter Dynamics Model

📝 Experiment Overview: Learn the motion mechanism and unified modeling framework of quadcopter UAVs, constructing power units, control efficiency, rigid body dynamics, and kinematics models in a modular fashion to achieve six-degree-of-freedom dynamics simulation.

Experiment 51: Static Thrust Decomposition Model Identification Experiment

📝 Experiment Overview: Perform static and dynamic model decomposition identification of the motor-propeller unit using MATLAB, learning static and frequency domain model fitting methods from PWM to RPM, and from RPM to thrust/counter-torque.

Experiment 52: UUV Underwater VINS Simulation

📝 Experiment Overview: Test the stability and accuracy of the VINS-Fusion algorithm in a simulated water environment using the UUV model compiled and generated by Simulink, and fuse it with the tether positioning system to improve system fault tolerance.

Experiment 53: VTOL Mode Switching

📝 Experiment Overview: In-depth study of the smooth switching mechanism between multirotor and fixed-wing modes for VTOL aircraft, achieving precise flight trajectory control via the MAVLink protocol, and validating SITL and HIL simulations.

Experiment 54: Ackermann Chassis UGV Velocity Control

📝 Experiment Overview: Use Matlab to control the velocity of multiple UGVs in software/hardware-in-the-loop simulation mode, learning the Ackermann chassis model and external control interfaces.

Experiment 55: Software/Hardware-in-the-Loop Simulation of Multiple UGV Velocity Control

📝 Experiment Overview: Use Matlab and the RflySim toolchain to achieve velocity control of multiple differential drive UGVs through software/hardware-in-the-loop simulation, learning external control interfaces and simulation configuration methods.

Experiment 56: Multirotor Power System Dynamic Thrust Measurement

📝 Experiment Overview: Learn to test and record the data required for the multirotor power system dynamic thrust model, including PWM input and propeller

4.5.4 Advanced Development Experiments

Stored in the 4.RflySimModel\3.CustExps folder, these experiments are designed for advanced users engaged in custom development.

Experiment 1: Advanced Custom Model Interface Experiment

📝 Experiment Overview: A centralized explanation of commonly used advanced input interfaces and parameter injection interfaces in custom model development, including extended control input, GPS origin configuration, initialization parameter injection, fault parameter injection, dynamic parameter modification, flight controller state input, and UE scene interaction input, helping users build an overall understanding of model external interfaces.

Experiment 2: High-Precision Helicopter Model Design and Validation Based on System Template

📝 Experiment Overview: Use MATLAB/Simulink to generate a helicopter DLL model file, validate the helicopter model through software/hardware-in-the-loop simulation, and learn the operational steps for model generation, SIL, and HIL simulation.

Experiment 3: High-Precision Unmanned Surface Vehicle (USV) Model Design and Validation Based on System Template

📝 Experiment Overview: Learn to compile Simulink files to generate a USV DLL model file, import it into the platform for software/hardware-in-the-loop simulation testing, and become familiar with the use of the USV model.

Experiment 4: UUV Model DLL Generation and Software/Hardware-in-the-Loop Simulation Experiment

📝 Experiment Overview: Learn to compile and generate a UUV (Unmanned Underwater Vehicle) model DLL file in Matlab, and perform hardware-in-the-loop simulation testing using a remote controller, becoming familiar with the use of the UUV model.

Experiment 5: External Sensor - Sound Localization Experiment

📝 Experiment Overview: This experiment implements sound sensor data acquisition and processing through the RflySim toolchain and UE4 engine, learning UDP audio reception, WAV file saving, and waveform plotting, mastering sound localization technology in a virtual environment.

Experiment 6: External Sensor - Optical Flow Localization (UE-Based Computation)

📝 Experiment Overview: Learn two methods for computing optical flow in UE: one based on ground truth and the other based on OpenCV. By modifying sensor configurations and running Python scripts, compare optical flow calculation results with the drone's motion ground truth.

Experiment 7: VTOL Aircraft Model Design and Control

📝 Experiment Overview: This experiment is used to complete the model design, DLL generation, and software/hardware-in-the-loop validation of vertical takeoff and landing aircraft and tail-sitter configurations, helping users become familiar with the modeling and usage workflow of standard VTOL, high-precision VTOL, dual-rotor tailsitter, and quad-rotor tailsitter models.

Experiment 8: Trailer Model Control Experiment

📝 Experiment Overview: Introduces the DLL generation, software/hardware-in-the-loop simulation, and comprehensive model closed-loop validation process for high-precision trailer/unmanned ground vehicle models, helping users become familiar with the use of the platform's refined ground vehicle models.

Experiment 9: CopterSimSIL Comprehensive Model Simulation Without PX4

📝 Experiment Overview: This experiment builds closed-loop simulations of comprehensive models for fixed-wing, multirotor, compound multirotor, and SimScape quadrotor based on Simulink DLL models, helping users become familiar with controller integration and external control validation processes for different vehicles.

Experiment 10: Multirotor Model Design and Closed-Loop Validation Based on Power System Identification

📝 Experiment Overview: Demonstrates the method of building a multirotor model based on power system identification results and performing closed-loop validation, covering platforms such as FSJ 150 and FX450, helping users become familiar with the DLL generation, SIL/HIL simulation, and parameter migration workflow of identification models.

Experiment 11: External Sensor Series Experiments

📝 Experiment Overview: This experiment summarizes external sensor extension experiments, covering typical scenarios such as external GPS, sound localization, and optical flow localization, helping users understand how to combine UE scenes, Python scripts, and RflySim sensor interfaces, providing an introduction to custom perception systems.

Experiment 12: BlueprintCopter

📝 Experiment Overview: Learn to use the comprehensive model based on the UE physics engine and Blueprint controller, load and manipulate the Blueprint quadrotor drone via Python scripts, supporting terrain and collision response.

Experiment 13: Blueprint Vehicle Control Experiment

📝 Experiment Overview: Learn to use the vehicle model developed based on UE's built-in WheeledVehicle system, implement vehicle motion control logic, supporting terrain and collision response.

Experiment 14: Blueprint Fixed-Wing Model Experiment

📝 Experiment Overview: Implement a simplified fixed-wing aircraft dynamics model based on UE4 Blueprints, conduct vehicle motion control logic experiments through RflySim3D, and learn the implementation principles and control methods of the Blueprint model.

Experiment 15: FaultInParam Dynamic Parameter Modification Verification Experiment

📝 Experiment Overview: Use the FaultInParam dynamic parameter modification interface to simulate a motor output zero fault during software-in-the-loop simulation, observe the quadcopter's landing effect, and learn the UDP communication mechanism and dynamic parameter modification principles.

Experiment 16: Fixed-Wing Comprehensive Model Design and Simulation Validation

📝 Experiment Overview: Design a fixed-wing controller based on MATLAB/Simulink, build a comprehensive model, and achieve simulation validation of fixed-wing arming, takeoff, position control, and return-to-home through external control.

Experiment 17: Fault Injection API Test

📝 Experiment Overview: Inject a motor fault into a flying aircraft through the RflySim platform's fault injection interface, causing a crash, and verify the communication interface and fault injection functionality.

Experiment 18: inCtrlExt Series Input Interface Matlab Usage

📝 Experiment Overview: Use the RflySim platform's inCtrlExt series input interfaces via Matlab to input external control signals into the simulation model, dynamically modify 3D display parameters, and achieve real-time transformation of the displayed aircraft model during simulation.

Experiment 19: PX4 State Flag Experiment

📝 Experiment Overview: Read the PX4 VTOL_STATE flag bit through the inCopterData(5) interface, observe the state changes of a VTOL drone during multirotor, fixed-wing, and transition phases, and display them on the RflySim 3D interface using ExtToUE4.

Experiment 20: Tethered Drone Modeling and Simulation

📝 Experiment Overview: Validate the dynamic effects and control behavior of a drone connected to a ground anchor point via a tether on the RflySim/CopterSim platform, demonstrating how to generate a DLL from a Simulink model with a tether model and run it in software/hardware-in-the-loop.

Experiment 21: TrailerModelCtrl Refined Unmanned Ground Vehicle Model Design and Validation

📝 Experiment Overview: Learn to compile Simulink files in Matlab to generate a refined unmanned ground vehicle DLL model file, and perform software/hardware-in-the-loop simulation testing, becoming familiar with the use of the platform's refined unmanned ground vehicle model.

Experiment 22: VTOL Model Control

📝 Experiment Overview: Learn the DLL model generation, software-in-the-loop simulation, and hardware-in-the-loop simulation of a standard vertical takeoff and landing aircraft, mastering VTOL modeling and usage.

Experiment 23: Initial Parameter Dynamic Injection

📝 Experiment Overview: Learn to inject initial parameters via CSV, Python, or Matlab before starting the DLL model, enabling batch scenario switching and initialization configuration, reducing the uncertainty of temporary modifications during runtime.

Experiment 24: FaultParamAPI.InitInParams Parameter Dynamic Modification Experiment

📝 Experiment Overview: Dynamically modify the FaultParamAPI.InitInParams parameter in the model using the CSV file injection method, achieving changes in the model state during simulation, helping users become familiar with the file injection dynamic modification method.

Experiment 25: inFromUE Input Interface Experiment

📝 Experiment Overview: Issue weather commands through the RflySim3D UI or Blueprint interface, dynamically change the road physical friction coefficient, simulate realistic skidding physical constraints, and learn the dynamic linkage mechanism between weather and surface friction.

Experiment 26: Fault Parameter Injection Experiment

📝 Experiment Overview: Learn how to inject fault parameters into the DLL model during simulation, trigger abnormal conditions such as motor faults via Matlab, Python, or supporting validation models, for fault-tolerant control, fault evolution, and system robustness testing.

Experiment 27: FaultInParams Fault Parameter Input Interface Matlab Experiment

📝 Experiment Overview: Input data to the FaultParamAPI.FaultInParams interface of the RflySim platform DLL model via Matlab to implement fault injection, learning the usage of the fault parameter input interface.

Experiment 28: Python Control of inCtrlExt Interface Experiment

📝 Experiment Overview: Control the RflySim platform's inCtrlExt series input interfaces via a Python program to achieve real-time transformation of the 3D display model of a quadrotor drone during software-in-the-loop simulation.

Experiment 29: Quadrotor Comprehensive Model Design and Simulation Validation

📝 Experiment Overview: Design a quadrotor controller based on MATLAB/Simulink, combine it with the dynamics model to form a comprehensive model, and achieve software-in-the-loop simulation validation of position, velocity, yaw angle, and other commands through external control.

Experiment 30: Dual-Rotor Tailsitter Model Design and Validation

📝 Experiment Overview: Through this routine, become familiar with the DLL generation and software/hardware-in-the-loop simulation steps for the dual-rotor tailsitter model, learning model import, compilation, simulation, and waypoint mission execution.

Experiment 31: Unmanned Ground Vehicle Comprehensive Model Simulation Validation (Simulink External Control)

📝 Experiment Overview: Design an unmanned ground vehicle controller based on MATLAB/Simulink, combine it with the DLL model to form a comprehensive model, achieve top-level control through external control methods, and learn comprehensive model compilation, DLL generation, and simulation validation.

Experiment 32: Python Dynamic Modification of InitInParams Parameter Experiment

📝 Experiment Overview: Dynamically modify the FaultParamAPI.InitInParams parameter in the model via a Python program to achieve changes in the model state during simulation, allowing users to become familiar with the dynamic modification method of this parameter.

Experiment 33: DynModiParams Dynamic Parameter Modification Experiment

📝 Experiment Overview: Introduces how to dynamically modify model parameters by calling the sendDynModiParams() function via Python to the FaultParamAPI.DynModiParams interface during RflySim simulation, achieving functions such as switching 3D display models.

Experiment 34: Hexarotor Comprehensive Model Design and Simulation Validation

📝 Experiment Overview: Design a hexarotor controller based on MATLAB/Simulink, integrate it with the dynamics model to form a comprehensive model, achieve top-level control through external control, and learn the Offboard control protocol and simulation validation.

Experiment 35: Matlab Initialization Parameter Interface Experiment

📝 Experiment Overview: Input data to the FaultParamAPI.InitInParams interface via Matlab to modify the 3D model display type, learning the DLL model parameter initialization method.

Experiment 36: Python Parameter Input Interface Experiment

📝 Experiment Overview: Call the sendInitInParams() function in the DllSimCtrlAPI library via Python to input data to the FaultParamAPI.InitInParams interface, achieving initialization parameter configuration for the drone model.

Experiment 37: Python Fault Injection Parameter Interface Experiment

📝 Experiment Overview: Call the sendModelInParams() function in the DllSimCtrlAPI library via Python to input data to the FaultParamAPI.FaultInParams interface, achieving quadrotor fault injection simulation, and observe the drone's takeoff, hover, and crash phenomena.

Experiment 38: VTOL High-Precision Model Control

📝 Experiment Overview: Learn the modeling and usage of vertical takeoff and landing aircraft, including DLL model generation, software-in-the-loop simulation, and hardware-in-the-loop simulation testing.

Experiment 39: Quad-Axis Octocopter Comprehensive Model Design and Simulation Validation

📝 Experiment Overview: Design a quad-axis octocopter controller and dynamics model based on MATLAB/Simulink to form a comprehensive simulation closed loop, achieve top-level control through external control, and learn model compilation, DLL generation, and simulation validation.

Experiment 40: Quadrotor Tailsitter Model Software/Hardware-in-the-Loop Simulation

📝 Experiment Overview: Through this routine, become familiar with the software/hardware-in-the-loop simulation steps for the quadrotor tailsitter model, including model import, DLL generation, software-in-the-loop simulation, and hardware-in-the-loop simulation, learning its dynamic characteristics and control channel mapping.

Experiment 41: Octocopter Comprehensive Model Design and Simulation Validation

📝 Experiment Overview: Design an octocopter controller based on MATLAB/Simulink, integrate it with the dynamics model to form a comprehensive model, achieve SIL simulation through external control, covering steps such as compilation, DLL generation, simulation startup, and Offboard control.

Experiment 42: ParamAPI Parameter Dynamic Injection Experiment

📝 Experiment Overview: Inject initial parameters, fault parameters, and runtime dynamic parameters into the DLL model via FaultParamAPI, achieving parameter configuration, fault triggering, and online parameter adjustment verification.

Experiment 43: Compound Multirotor Comprehensive Model Design and Simulation Validation

📝 Experiment Overview: Based on Matlab external control, use UDP flag bit switching to achieve dynamic switching and simulation validation of quadrotor, hexarotor, octocopter, and quad-axis octocopter models.

Experiment 44: Compound Multirotor Comprehensive Model Simulation (Python External Control)

📝 Experiment Overview: Modify the compound multirotor comprehensive model based on the quadrotor comprehensive model, supporting simulation switching between quadrotor, hexarotor, octocopter, and quad-axis octocopter, sending control commands and switching commands via Python UDP port 30100.

Experiment 45: SimScape Quadrotor Comprehensive Model Simulation

📝 Experiment Overview: Build a quadrotor drone comprehensive model using SimScape graphical physical components, understand the differences from traditional dynamics equation modeling, master the model compilation and DLL file generation workflow, and run the simulation on the RflySim platform.

Experiment 46: FSJ150 Identification Model DLL Generation and SIL/HIL Experiment

📝 Experiment Overview: Learn to compile Simulink models in Matlab to generate DLL files for the FSJ 150 identification model, and perform software-in-the-loop and hardware-in-the-loop simulation testing, becoming familiar with the use of the platform's identification model.

Experiment 47: FSJ200 Quadrotor System Identification Model DLL Generation and SIL/HIL Experiment

📝 Experiment Overview: Learn to compile Simulink models in Matlab to generate DLL files for the FSJ200 identification model, and perform software/hardware-in-the-loop simulation testing, becoming familiar with the use of the platform's identification model.

Experiment 48: FX150 Quadrotor System Identification Model DLL Generation and SIL/HIL Experiment

📝 Experiment Overview: Learn to compile and generate DLL files for the FX150 quadrotor identification model in Matlab, and perform software-in-the-loop and hardware-in-the-loop simulation testing, becoming familiar with the usage workflow of the identification model.

Experiment 49: FX200 Quadrotor Identification Model DLL Generation and SIL/HIL Experiment

📝 Experiment Overview: Learn to compile and generate DLL files for the FX200 identification model in Matlab, and perform software-in-the-loop and hardware-in-the-loop simulation testing, becoming familiar with the use of the platform's identification model.

Experiment 50: FX450 Identification Model DLL Generation and SIL/HIL Experiment

📝 Experiment Overview: Learn to compile and generate DLL files for the FX450 quadrotor identification model in Matlab, and perform software-in-the-loop and hardware-in-the-loop simulation testing, becoming familiar with the usage method of the identification model.

Experiment 51: GPS Initial Position and Reference Origin Configuration

📝 Experiment Overview: Configure the drone's GPS initial position and reference origin in the simulation via a bat script, supporting software-in-the-loop and hardware-in-the-loop simulation, enabling initial position setting for multiple drones.