Road Runner
Search…
Coordinate Frames
The previous discussion of motion profiling wraps up motion control for mechanisms with one degree of freedom. The remainder of the tour will extend these ideas to 2D robot movement.

Basics

In order to describe 2D motion, we need a consistent global coordinate frame. Within this global frame, the robot's position can be described using typical Cartesian
(x,y)(x,y)
coordinates. In addition to the linear position, the robot has a heading
θ\theta
defined as the angle between the front of the robot and the global
xx
axis. The position and heading together constitute the robot's pose.
2D vectors and poses are built into the library and serve as primitives for many other classes.
Java
Kotlin
1
Vector2d position = new Vector2d(x, y);
2
Pose2d pose = new Pose2d(position, theta);
Copied!
1
val position = Vector2d(x, y)
2
val pose = Pose2d(position, theta)
Copied!
In addition to the global coordinate frame, there is a robot coordinate frame that moves along with the robot. Paths are more conveniently described in the global frame while robot velocities are more conveniently described in the robot frame. To accommodate this, Road Runner constantly switches between frames.

Transformations

Transformation of a velocity vector between frames
Consider a velocity vector
vG\vec{v}_G
in the global frame. To find the equivalent representation
vR\vec{v}_R
in the robot frame, we can apply a rotation transformation. This transformation can be represented by the following matrix:
If you haven't seen matrices and vectors before, check out 3Blue1Brown's series Essence of linear algebra. The first four videos are the most relevant to this section, although I strongly recommend all of them.
2D rotation matrix
With this matrix, the transformation is simple:
vG=R(θ)vR\vec{v}_G = R(\theta) \, \vec{v}_R
. Since the inverse of
R(θ)R(\theta)
is just
R(θ)R(-\theta)
,
vR=R(θ)vG\vec{v}_R = R(-\theta) \, \vec{v}_G
. Note the angular velocity
ω\omega
remains the same between frames.
As you might expect, rotations are built into the Vector2d class:
Java
Kotlin
1
Vector2d v = new Vector2d(x, y);
2
Vector2d w = v.rotated(rotAngleRad);
Copied!
1
val v = Vector2d(x, y)
2
val w = v.rotated(rotAngleRad)
Copied!
More sophisticated transformations can be found in Kinematics. For instance, the aforementioned pose-to-pose velocity transformation is Kinematics.fieldToRobotVelocity().
Last modified 1yr ago
Copy link