Swerve Drive Kinematics¶
SwerveDriveKinematics class is a useful tool that converts between a
ChassisSpeeds object and several
SwerveModuleState objects, which contains velocities and angles for each swerve module of a swerve drive robot.
The swerve module state class¶
SwerveModuleState class contains information about the velocity and angle of a singular module of a swerve drive. The constructor for a
SwerveModuleState takes in two arguments, the velocity of the wheel on the module, and the angle of the module.
In Java, the velocity of the wheel must be in meters per second. In C++, the units library can be used to provide the velocity using any linear velocity unit.
An angle of 0 corresponds to the modules facing forward.
Constructing the kinematics object¶
SwerveDriveKinematics class accepts a variable number of constructor arguments, with each argument being the location of a swerve module relative to the robot center (as a
Translation2d. The number of constructor arguments corresponds to the number of swerve modules.
A swerve drive must have 2 or more modules.
In C++, the class is templated on the number of modules. Therefore, when constructing a
SwerveDriveKinematics object as a member variable of a class, the number of modules must be passed in as a template argument. For example, for a typical swerve drive with four modules, the kinematics object must be constructed as follows:
The locations for the modules must be relative to the center of the robot. Positive x values represent moving toward the front of the robot whereas positive y values represent moving toward the left of the robot.
Converting chassis speeds to module states¶
toSwerveModuleStates(ChassisSpeeds speeds) (Java) /
ToSwerveModuleStates(ChassisSpeeds speeds) (C++) method should be used to convert a
ChassisSpeeds object to a an array of
SwerveModuleState objects. This is useful in situations where you have to convert a forward velocity, sideways velocity, and an angular velocity into individual module states.
The elements in the array that is returned by this method are the same order in which the kinematics object was constructed. For example, if the kinematics object was constructed with the front left module location, front right module location, back left module location, and the back right module location in that order, the elements in the array would be the front left module state, front right module state, back left module state, and back right module state in that order.
Recall that a
ChassisSpeeds object can be created from a set of desired field-oriented speeds. This feature can be used to get module states from a set of desired field-oriented speeds.
Using custom centers of rotation¶
Sometimes, rotating around one specific corner might be desirable for certain evasive manuevers. This type of behavior is also supported by the WPILib classes. The same
ToSwerveModuleStates() method accepts a second parameter for the center of rotation (as a
Translation2d). Just like the wheel locations, the
Translation2d representing the center of rotation should be relative to the robot center.
Because all robots are a rigid frame, the provided
vy velocities from the
ChassisSpeeds object will still apply for the entirety of the robot. However, the
omega from the
ChassisSpeeds object will be measured from the center of rotation.
For example, one can set the center of rotation on a certain module and if the provided
ChassisSpeeds object has a
vy of zero and a non-zero
omega, the robot will appear to rotate around that particular swerve module.
Converting module states to chassis speeds¶
One can also use the kinematics object to convert an array of
SwerveModuleState objects to a singular
ChassisSpeeds object. The
toChassisSpeeds(SwerveModuleState... states) (Java) /
ToChassisSpeeds(SwerveModuleState... states) (C++) method can be used to achieve this.