Actuator Model

The model specifies the fundamental actuator type, which dictates its core dynamic equation. Common types include:

• Rotational/Rotary Actuators: Modeled as applying torque (τ) to produce angular acceleration (α), governed by τ = Iα, where I is the rotational inertia.
• Linear/Prismatic Actuators: Modeled as applying force (F) to produce linear acceleration (a), governed by F = ma.
• Series Elastic Actuators (SEAs): Include an internal spring model, creating a dynamic relationship between motor position and output force, crucial for modeling compliance and safe human-robot interaction. The dynamics model calculates the acceleration resulting from the net torque/force after accounting for inertia and any modeled internal dynamics.

This defines how a software controller interacts with the simulated actuator. Standard interfaces mirror real-world motor controllers:

• Position Control: The controller sends a desired angle or extension. The actuator model's internal control loop (e.g., a PID controller) drives the joint to that setpoint.
• Velocity Control: The controller commands a target rotational or linear speed.
• Torque/Force Control: The most direct interface, where the controller commands the exact torque or force to be applied by the actuator. This mode requires an accurate dynamics model for stable simulation.
• Effort Limits: Absolute maximum torque/force the actuator can generate, a key parameter for all control modes.

Physical actuators have hard performance boundaries that must be enforced in simulation to prevent unrealistic behavior. The model applies saturation to the control input or computed output. Key limits include:

• Position Limits: Minimum and maximum joint angles or linear travel, often defined by mechanical stops.
• Velocity Limit: The maximum rotational speed (RPM or rad/s) or linear speed the actuator can achieve.
• Torque/Force Limit: The peak and continuous torque/force output, constrained by motor power, thermal limits, or gearbox ratings.
• Acceleration Limit: Some high-fidelity models include a maximum rate of change for torque/force to model electrical current slew rates. Enforcing these limits is essential for generating plausible trajectories and for training robust reinforcement learning policies.

For position or velocity control modes, the actuator model contains an internal controller that simulates the low-level electronics (like a motor driver) that closes the loop. The most common model is a Proportional-Integral-Derivative (PID) controller.

• Proportional Gain (Kp): Generates a control effort proportional to the error (difference between desired and actual state). High Kp increases responsiveness but can cause overshoot.
• Integral Gain (Ki): Accumulates past error to eliminate steady-state offset (e.g., holding a position against gravity).
• Derivative Gain (Kd): Dampens the response based on the rate of error change, reducing oscillation and overshoot. Tuning these gains defines the actuator's stiffness, damping, and response time, dramatically affecting the simulated robot's stability and task performance.

To close the reality gap, high-fidelity actuator models include dissipative effects that oppose motion:

• Viscous Friction: A force proportional to velocity (F = -b*v). This is the dominant loss in systems moving through fluid or in lubricated bearings.
• Coulomb (Dry) Friction: A constant force opposing the direction of motion, independent of velocity. It models static "stiction" and sliding friction in dry contacts.
• Motor Back-EMF: In electric motors, a voltage proportional to speed is generated that opposes the driving current, effectively creating a velocity-dependent damping effect.
• Gearbox Losses: Modeled as an efficiency factor (e.g., 0.85) that scales down output torque while scaling up reflected inertia. Omitting these losses leads to simulated robots that are more efficient and easier to control than their physical counterparts.

The actuator model accounts for the inertia it must overcome, which includes:

• Rotor Inertia: The intrinsic inertia of the motor's own rotating mass.
• Reflected Inertia: For geared actuators, the inertia of the load (the robot link) is "reflected" back through the gearbox to the motor shaft. It is scaled by the square of the gear ratio (J_reflected = J_load / (GR^2)). A high gear ratio makes the load feel much lighter to the motor but also reduces maximum speed.
• Added Inertia: Some models allow specifying additional inertial components attached to the actuator output. Accurate inertia modeling is critical for inverse dynamics calculations and for simulating the actuator's acceleration capabilities and sensitivity to external disturbances.

An actuator model is the software abstraction that sits between a robot's control policy and the physics engine. It converts desired control signals (e.g., target position, velocity, or torque) into the actual forces or torques applied to a simulated joint. This involves:

• Interpreting control modes: Position control, velocity control, or direct torque control.
• Applying physical limits: Enforcing maximum torque, velocity, and position bounds to prevent unrealistic behavior.
• Modeling internal dynamics: Simulating effects like motor inertia, damping, and gearbox backlash that exist in real hardware.

High-fidelity actuator models incorporate several real-world physical effects to close the reality gap:

• Torque-Velocity Curve: Models the reduction in available output torque as motor speed increases, a fundamental limit of electric motors.
• Friction: Includes viscous friction (proportional to velocity) and Coulomb (static) friction.
• Control Response: Often models a PID controller within the actuator, complete with tunable gains (Kp, Ki, Kd), integral windup limits, and control frequency.
• Backlash & Hysteresis: Simulates the dead zone in geared transmissions where input motion does not immediately cause output motion.
• Thermal Limits: Advanced models may include thermal dynamics, reducing maximum torque output as the motor overheats.

Different robotic joints require different actuator abstractions:

• Rotational Actuators: Model motors for revolute joints (e.g., robot arm elbows, wheel motors). Defined by maximum torque (Nm) and angular velocity (rad/s).
• Linear Actuators: Model pistons or lead screws for prismatic joints. Defined by maximum force (N) and extension velocity (m/s).
• Position-Controlled Servos: Common in hobbyist robots; modeled with strict position tracking and limited torque.
• Direct-Drive Actuators: High-torque, low-gear-ratio motors often used in legged robots; modeled with minimal backlash but significant motor inertia.
• Hydraulic/Pneumatic Actuators: Model fluid-based systems with complex dynamics involving pressure, flow rates, and valve response times.

Actuator models are configured within a robot's description file and managed by the physics engine's solver.

• URDF/SDF Tags: Parameters like <limit>, <dynamics>, and <mimic> in URDF or SDF files define the actuator's operational bounds and simple dynamics.
• Engine-Specific Plugins: High-fidelity models (e.g., detailed motor dynamics) are often implemented as plugins for simulators like Gazebo, NVIDIA Isaac Sim, or MuJoCo.
• Solver Interaction: During each time step, the physics engine's constraint solver (e.g., a constraint-based solver) uses the actuator's output force/torque to compute the resulting acceleration in the rigid-body dynamics system.

The accuracy of the actuator model is paramount for successful sim-to-real transfer. An oversimplified model leads to a large reality gap.

• Policy Brittleness: A policy trained with ideal, instantaneous actuators will fail on physical hardware with latency and dynamics.
• Domain Randomization Strategy: Key actuator parameters (e.g., max torque, PID gains, friction coefficients) are often randomized during training to promote robustness.
• Hardware-in-the-Loop (HIL) Validation: The simulated actuator model is validated by comparing its step response to data from the physical motor and controller.

Each physics simulation platform provides tools for actuator modeling:

• MuJoCo: Offers highly configurable actuator models with built-in support for muscle-tendon units, cylinders, and motors. Its mjModel structure defines actuator transmission, gain, and bias.
• PyBullet / Bullet: Provides velocity, position, and torque control modes with optional PD control for the first two. Users can set maxVelocity and maxForce per joint.
• NVIDIA Isaac Sim: Uses the PhysX physics engine with ROS 2 control integrations, allowing detailed modeling of gear ratios, motor constants, and efficiency.
• Gazebo: Implements actuators via its plugin architecture and ROS control interfaces, allowing for complex, user-defined motor models.
• Drake: Provides a rich MultibodyPlant with explicit modeling of actuation, including multi-input actuators and detailed hydraulic systems.

The underlying software library that simulates Newtonian mechanics, providing the computational foundation for all physical interactions. It calculates rigid-body dynamics, performs collision detection, and resolves contact forces. An actuator model relies on the physics engine to translate computed joint torques into realistic motion. Popular engines include MuJoCo, Bullet (used by PyBullet), and PhysX.

Core computational models for predicting and controlling robot motion.

• Forward Dynamics: Calculates the resulting acceleration and motion of a robot given the actuator torques and external forces. This is what the simulation solves each time step.
• Inverse Dynamics: Calculates the actuator torques required to achieve a desired acceleration or trajectory. This is a fundamental operation for model-based controllers like computed-torque control.

An advanced real-time control strategy that uses an internal dynamic model (which includes the actuator model) to predict the robot's future behavior over a finite horizon. It then optimizes a sequence of control inputs (e.g., desired joint torques) to minimize a cost function (e.g., tracking error, energy use). The fidelity of the embedded actuator model directly impacts MPC's performance and stability.

The overarching challenge of deploying policies or controllers trained in simulation onto physical hardware. A critical source of failure is the reality gap, often caused by inaccuracies in the simulated actuator model (e.g., idealized torque limits, missing friction or backlash). Techniques like domain randomization are used to vary actuator parameters during training to encourage the learning of robust policies that bridge this gap.

File formats that define a robot's physical structure for simulation.

• URDF (Unified Robot Description Format): An XML format that describes a robot's links, joints, visual geometry, and inertial properties. It can include basic actuator limits.
• SDF (Simulation Description Format): A more comprehensive, world-centric format that can define complete scenes with nested models, lights, and sensors. It supports more detailed actuator and transmission modeling than URDF. These files provide the kinematic and inertial parameters that the actuator model acts upon.

A validation methodology where physical hardware—such as the actual robot controller or motor driver—is connected to a real-time simulation. The simulation provides virtual sensor feedback and runs a high-fidelity actuator model and physics engine. This tests the real controller's behavior against a simulated robot body before physical assembly, catching integration errors early.