Motion controller

The motion controller turns the references a behavior sends into commands the platform accepts, and its plugin holds the control law. How the controller picks a mode and when it steps aside is on the motion controller concept page.

Choosing a plugin

• PID speed works with any platform that takes velocities, which is most real drones, Gazebo and the multirotor simulator. It's the only one that serves speed in a plane.
• Differential flatness tracks trajectories on a platform that takes body rates and thrust, and uses the trajectory's acceleration as a feed-forward. It only takes trajectories, so the behaviors need their trajectory plugins.
• Geometric also drives body rates with the trajectory's acceleration as a feed-forward, but takes position and speed references too. When the platform doesn't take body rates, or the mass isn't set, it sends velocities instead.

Running it

ros2 launch as2_motion_controller controller_launch.py \
  namespace:=drone0 \
  plugin_name:=pid_speed_controller \
  plugin_config_file:=config/pid_speed_controller.yaml

Add use_sim_time:=true in simulation. Your plugin file is merged over the plugin's defaults, so it only needs the gains you change. The gains sit under the plugin's name:

/**:
  ros__parameters:
    pid_speed_controller:
      position_control:
        kp: {x: 1.0, y: 1.0, z: 1.0}
        ki: {x: 0.01, y: 0.01, z: 0.01}
      yaw_control:
        kp: 1.0

Gains can be changed while flying, for example to tune them:

ros2 param set /drone0/controller_manager pid_speed_controller.position_control.kp.x 1.5

PID speed

PID loops that turn each kind of reference into a velocity and a yaw rate. With a position reference, a PID on the position error gives the velocity. With a trajectory, one PID acts on the position error with its derivative on the velocity error. The setpoint's acceleration isn't used. With speed in a plane, the height comes from its own PID on the reference height.

Each loop takes these settings, shown here for position_control:

The default alpha of 0 turns the derivative off, so raise it before tuning kd. A few loops differ from the pattern:

• yaw_control and speed_in_a_plane_control.height take single gains, with no axes.
• speed_in_a_plane_control.speed takes x and y only.
• speed_in_a_plane_control takes antiwindup_cte, alpha and reset_integral once, for both its loops. Its antiwindup_cte only reaches the height loop for now.
• trajectory_control ignores alpha.

A mode needs non-zero gains in its loop, and every mode needs a yaw gain. Speed references are the exception while use_bypass is on. Speed in a plane still needs a non-zero speed gain, even with bypass on.

With a position reference, the speed the behavior sends becomes a speed limit on each axis. The plugin's use_bypass is separate from the controller's own. When the controller's is on and the platform takes velocities, speed references skip the plugin entirely.

Differential flatness

Computes the force the drone needs from the position and velocity errors, gravity and the trajectory's acceleration. It turns that force into a desired attitude and sends body rates toward it, with the thrust in newtons.

Set mass to your drone's real mass. The platform has to take thrust in newtons.

Geometric

Cascaded PID loops from position to velocity to acceleration, followed by a geometric attitude controller that sends body rates and thrust in newtons. Trajectories skip the cascade and use one PID plus the trajectory's acceleration.

When it sends velocities instead, it stops after the position loop and sends the velocity with a yaw rate. Trajectories then use the position gains plus the trajectory's velocity.

The kp, ki and kd gains are lists of three values, for x, y and z. The other settings are single values.

To use the acceleration limits, set both, with every value of saturation_lower below saturation_upper. Setting only the upper one leaves the lower at 0, which blocks every negative acceleration.

Only the kp gains decide which modes are available:

With a position reference, the speed the behavior sends limits the size of the velocity. Debug topics are set with debug.desired_velocity_topic, debug.acceleration_topic and debug.velocity_norm_topic.