Introduction to Kinematics and The ChassisSpeeds Class

Note

Kinematics and odometry uses a common coordinate system. You may wish to reference the Coordinate System section for details.

Qu’est-ce que la cinématique?

The kinematics suite contains classes for differential drive, swerve drive, and mecanum drive kinematics and odometry. The kinematics classes help convert between a universal ChassisSpeeds (Java, C++, Python)object, containing linear and angular velocities for a robot to usable speeds for each individual type of drivetrain i.e. left and right wheel speeds for a differential drive, four wheel speeds for a mecanum drive, or individual module states (speed and angle) for a swerve drive.

Qu’est-ce que l’odométrie?

L’odométrie consiste à utiliser des capteurs sur le robot pour créer une estimation de la position du robot sur le terrain de jeu. En FRC, ces capteurs sont généralement composés de plusieurs encodeurs (le nombre exact dépend du type d’entraînement) et d’un gyroscope pour mesurer l’angle du robot. Les classes d’odométrie utilisent les classes cinématiques ainsi que les entrées périodiques de l’utilisateur sur les vitesses (et les angles en cas de déviation) pour créer une estimation de l’emplacement du robot sur le terrain.

The ChassisSpeeds Class

L’objet ChassisSpeeds est essentiel à la nouvelle suite cinématique et odométrique WPILib. L’objet ChassisSpeeds représente les vitesses d’un châssis de robot. Cette structure a trois composants:

  • vx: La vitesse du robot dans la direction x (avant).

  • vy: La vitesse du robot dans la direction y (latérale). (Les valeurs positives signifient que le robot se déplace vers la gauche).

  • omega: La vitesse angulaire du robot en radians par seconde.

Note

Une transmission non holonomique (c’est-à-dire une transmission qui ne peut pas se déplacer latéralement, ex: un entraînement différentiel) aura une composante vy de zéro en raison de son incapacité à se déplacer latéralement.

Construction d’un objet ChassisSpeeds

The constructor for the ChassisSpeeds object is very straightforward, accepting three arguments for vx, vy, and omega. In Java and Python, vx and vy must be in meters per second. In C++, the units library may be used to provide a linear velocity using any linear velocity unit.

// The robot is moving at 3 meters per second forward, 2 meters
// per second to the right, and rotating at half a rotation per
// second counterclockwise.
var speeds = new ChassisSpeeds(3.0, -2.0, Math.PI);

// The robot is moving at 3 meters per second forward, 2 meters
// per second to the right, and rotating at half a rotation per
// second counterclockwise.
frc::ChassisSpeeds speeds{3.0_mps, -2.0_mps,
  units::radians_per_second_t(std::numbers::pi)};

import math
from wpimath.kinematics import ChassisSpeeds

# The robot is moving at 3 meters per second forward, 2 meters
# per second to the right, and rotating at half a rotation per
# second counterclockwise.
speeds = ChassisSpeeds(3.0, -2.0, math.pi)

Création d’un objet ChassisSpeeds à partir de vitesses relatives au terrain de jeu

Un objet ChassisSpeeds peut également être créé à partir d’un ensemble de vitesses relatives au terrain lorsque l’angle du robot est connu. L’objet utilise un ensemble de vitesses souhaitées par rapport au terrain (par exemple, vers la station d’alliance opposée, à droite sur le terrain) et calcule et génère un objet ChassisSpeeds qui représente des vitesses relatives au châssis du robot. Ceci est utile pour mettre en œuvre des contrôles orientés sur le terrain pour un robot avec un mécanisme de type « à embardée » ou Mécanum.

The static ChassisSpeeds.fromFieldRelativeSpeeds (Java / Python) / ChassisSpeeds::FromFieldRelativeSpeeds (C++) method can be used to generate the ChassisSpeeds object from field-relative speeds. This method accepts the vx (relative to the field), vy (relative to the field), omega, and the robot angle.

// The desired field relative speed here is 2 meters per second
// toward the opponent's alliance station wall, and 2 meters per
// second toward the left field boundary. The desired rotation
// is a quarter of a rotation per second counterclockwise. The current
// robot angle is 45 degrees.
ChassisSpeeds speeds = ChassisSpeeds.fromFieldRelativeSpeeds(
  2.0, 2.0, Math.PI / 2.0, Rotation2d.fromDegrees(45.0));

// The desired field relative speed here is 2 meters per second
// toward the opponent's alliance station wall, and 2 meters per
// second toward the left field boundary. The desired rotation
// is a quarter of a rotation per second counterclockwise. The current
// robot angle is 45 degrees.
frc::ChassisSpeeds speeds = frc::ChassisSpeeds::FromFieldRelativeSpeeds(
  2_mps, 2_mps, units::radians_per_second_t(std::numbers::pi / 2.0), Rotation2d(45_deg));

import math
from wpimath.kinematics import ChassisSpeeds
from wpimath.geometry  import Rotation2d

# The desired field relative speed here is 2 meters per second
# toward the opponent's alliance station wall, and 2 meters per
# second toward the left field boundary. The desired rotation
# is a quarter of a rotation per second counterclockwise. The current
# robot angle is 45 degrees.
speeds = ChassisSpeeds.fromFieldRelativeSpeeds(
  2.0, 2.0, math.pi / 2.0, Rotation2d.fromDegrees(45.0))

Note

La vitesse angulaire n’est pas explicitement indiquée comme étant « relative au terrain » car la vitesse angulaire est la même que celle mesurée du point de vue du terrain ou du robot.