Utilisation des classes WPILib pour piloter votre robot

WPILib comprend de nombreuses classes pour faciliter le développement de la programmation et obtenir un robot fonctionnel plus rapidement.

Transmissions standard

Robots à entraînement différentiel

Le câblage d’un simple robot à entraînement différentiel.

Ces bases d’entraînement ont généralement deux ou plusieurs roues motrices en ligne ou omnidirectionnelles par côté (par exemple, 6WD ou 8WD) et peuvent également être appelées « skid-steer », « tank drive » ou « West Coast Drive ». La transmission du Kit de pièces est un exemple d’entraînement différentiel. Ces transmissions sont capables de faire avancer ou reculer le robot et peuvent le faire tourner en activant les moteurs de chaque côté dans des directions opposées, ce qui fait déraper les roues latéralement. Ces transmissions ne sont pas capables d’exécuter des mouvements de translation latéraux.

Entraînement de type Mécanum

Un robot Mecanum à quatre roues utilisant le châssis fourni dans le KOP.

L’entraînement Mécanum est une méthode de conduite utilisant des roues spécialement conçues qui permettent au robot de conduire dans n’importe quelle direction sans changer l’orientation du robot. Un robot avec une transmission conventionnelle (toutes les roues pointant dans la même direction) doit tourner dans la direction qu’il doit conduire. Un robot Mécanum peut se déplacer dans n’importe quelle direction sans avoir à tourner au préalable et est appelé un entraînement holonomique. Les roues (montrées sur ce robot) ont des rouleaux qui font que les forces de la conduite sont appliquées à un angle de 45 degrés plutôt que droit comme dans le cas d’un entraînement conventionnel.

Lorsqu’ils sont vus du haut, les rouleaux d’une transmission Mécanum doivent former un motif en “X”. Il en résulte que les vecteurs de force (lors de la conduite de la roue vers l’avant) sur les deux roues avant pointent vers l’avant et vers l’intérieur et les deux roues arrière pointent vers l’avant et vers l’extérieur. En faisant tourner les roues dans différentes directions, divers composants des vecteurs de force s’annulent, entraînant le mouvement souhaité du robot. Un tableau rapide des différents mouvements a été fourni ci-dessous, en traçant les vecteurs de force pour chacun de ces mouvements peut aider à comprendre comment ces transmissions fonctionnent. En faisant varier les vitesses des roues en plus de la direction, les mouvements peuvent être combinés, ce qui entraîne une translation dans n’importe quelle direction et rotation, simultanément.

Conventions utilisées par les classes

Motor Inversion

Depuis 2022, le côté droit de la transmission n’est plus inversé par défaut. Il est de la responsabilité de l’utilisateur de gérer les inversions appropriées de sa transmission. Les utilisateurs peuvent inverser les moteurs en appelant setInverted()/SetInverted() sur leurs objets moteurs.

JAVA

PWMSparkMax m_motorRight = new PWMSparkMax(0);

@Override
public void robotInit() {
   m_motorRight.setInverted(true);
}

C++

frc::PWMSparkMax m_motorLeft{0};

public:
 void RobotInit() override {
   m_motorRight.SetInverted(true);
 }

PYTHON

def robotInit(self):
    self.motorRight = wpilib.PWMSparkMax(0)
    self.motorRight.setInverted(True)

Squaring Inputs

Lors de la conduite de robots, il est souvent souhaitable de manipuler les entrées du joystick de sorte que le robot ait un contrôle plus précis à basse vitesse tout en utilisant toute la plage de sortie disponible. Une façon d’y parvenir est d’élever au carré la valeur absolue de l’entrée du joystick, puis de réappliquer le signe. Par défaut, la classe Differential Drive mettra les entrées au carré. Si cela n’est pas souhaité (par exemple, si vous transmettez des valeurs à partir d’un PIDController), utilisez l’une des méthodes d’entraînement et initialiser le paramètre squaredInputs à False.

Input Deadband

Par défaut, la classe DifferentialDrive applique une zone morte d’entrée de 0.02. Cela signifie que toutes les valeurs d’entrée qui sont inférieures à 0.02 (après la mise au carré décrite ci-dessus) seront plutôt considérées comme ayant une valeur de zéro. Dans la plupart des cas, ces petites valeurs d’entrée résultent d’un centrage imparfait du joystick et ne sont pas suffisantes pour provoquer un mouvement du robot. En appliquant une zone morte, on réduit l’échauffement des moteurs provenant de l’énergie appliquée inutilement aux moteurs, lorsque le robot ne bouge pas. Pour modifier la zone morte, utilisez la méthode setDeadband().

Maximum Output

Parfois, les pilotes ont l’impression que leur transmission roule trop vite et veulent limiter la sortie. Cela peut être accompli avec la méthode setMaxOutput(). Cette sortie maximale est multipliée par le résultat des fonctions d’entraînement précédentes comme deadband et squared inputs.

La sécurité moteur (Motor Safety)

Motor Safety est un mécanisme dans WPILib qui prend le concept d’un chien de garde (Watchdog) et crée une minuterie de sécurité pour chaque dispositif actionneur qui contrôle un moteur. Notez que ce mécanisme de protection s’ajoute au System Watchdog, celui-ci étant contrôlé par le code de communication réseau et le FPGA. Le Watchdog désactivera toutes les sorties du dispositif actionneur s’il ne reçoit pas de paquet de données valides pendant un délai de 125 ms.

The purpose of the Motor Safety mechanism is the same as the purpose of a watchdog timer, to disable mechanisms which may cause harm to themselves, people or property if the code locks up and does not properly update the actuator output. Motor Safety breaks this concept out on a per actuator basis so that you can appropriately determine where it is necessary and where it is not. Examples of mechanisms that should have motor safety enabled are systems like drive trains and arms. If these systems get latched on a particular value they could cause damage to their environment or themselves. An example of a mechanism that may not need motor safety is a spinning flywheel for a shooter. If this mechanism gets latched on a particular value it will simply continue spinning until the robot is disabled. By default Motor Safety is enabled for DifferentialDrive and MecanumDrive objects and disabled for all other motor controllers and servos.

La fonction Motor Safety d’un actionneur fonctionne en maintenant un timer qui surveille et enregistre le temps qui s’est écoulé depuis que le dernier appel de la méthode feed() pour cet actionneur. Un code dans la classe DriverStation initie une comparaison de ces timers aux valeurs de délai d’attente pour tout actionneur avec la sécurité activé tous les 5 paquets reçus (100ms nominal). Les méthodes set() de chaque classe de contrôleur de moteur et les méthodes set() et setAngle() de la classe servo font un appel à la méthode feed() pour indiquer que la sortie de l’actionneur a été mise à jour.

L’interface Motor Safety des contrôleurs moteurs peut être en interaction avec l’utilisateur par l’intermédiaire des méthodes suivantes:

JAVA

m_motorRight.setSafetyEnabled(true);
m_motorRight.setSafetyEnabled(false);
m_motorRight.setExpiration(.1);
m_motorRight.feed()

C++

m_motorRight->SetSafetyEnabled(true);
m_motorRight->SetSafetyEnabled(false);
m_motorRight->SetExpiration(.1);
m_motorRight->Feed();

PYTHON

m_motorRight.setSafetyEnabled(True)
m_motorRight.setSafetyEnabled(False)
m_motorRight.setExpiration(.1)
m_motorRight.feed()

Par défaut, tous les objets Drive activent la sécurité moteur. Selon le mécanisme et la structure de votre programme, vous pouvez souhaiter configurer la durée de temporisation de la sécurité moteur (en secondes). La durée du timeout est configurée par actionneur et n’est pas un paramètre global. La valeur par défaut (et minimale utile) est de 100 ms.

Conventions des axes

The drive classes use the NWU axes convention (North-West-Up as external reference in the world frame). The positive X axis points ahead, the positive Y axis points left, and the positive Z axis points up. We use NWU here because the rest of the library, and math in general, use NWU axes convention.

Joysticks follow NED (North-East-Down) convention, where the positive X axis points ahead, the positive Y axis points right, and the positive Z axis points down. However, it’s important to note that axes values are rotations around the respective axes, not translations. When viewed with each axis pointing toward you, CCW is a positive value and CW is a negative value. Pushing forward on the joystick is a CW rotation around the Y axis, so you get a negative value. Pushing to the right is a CCW rotation around the X axis, so you get a positive value.

Note

See the Coordinate System section for more detail about the axis conventions and coordinate systems.

Utilisation de la classe MecanumDrive pour contrôler les robots avec trains d’entraînement Mécanum

MecanumDrive est une méthode fournie pour le contrôle des transmissions holonomiques avec roues Mécanum, telles que le châssis du Kit de pièces, augmenté du kit Mécanum, comme illustré ci-dessus. Instancier un MecanumDrive est aussi simple que ceci:

JAVA

  private static final int kFrontLeftChannel = 2;
  private static final int kRearLeftChannel = 3;
  private static final int kFrontRightChannel = 1;
  private static final int kRearRightChannel = 0;

  @Override
  public void robotInit() {
    PWMSparkMax frontLeft = new PWMSparkMax(kFrontLeftChannel);
    PWMSparkMax rearLeft = new PWMSparkMax(kRearLeftChannel);
    PWMSparkMax frontRight = new PWMSparkMax(kFrontRightChannel);
    PWMSparkMax rearRight = new PWMSparkMax(kRearRightChannel);
    // Invert the right side motors.
    // You may need to change or remove this to match your robot.
    frontRight.setInverted(true);
    rearRight.setInverted(true);

    m_robotDrive = new MecanumDrive(frontLeft::set, rearLeft::set, frontRight::set, rearRight::set);
  }

C++

 private:
  static constexpr int kFrontLeftChannel = 0;
  static constexpr int kRearLeftChannel = 1;
  static constexpr int kFrontRightChannel = 2;
  static constexpr int kRearRightChannel = 3;

  frc::PWMSparkMax m_frontLeft{kFrontLeftChannel};
  frc::PWMSparkMax m_rearLeft{kRearLeftChannel};
  frc::PWMSparkMax m_frontRight{kFrontRightChannel};
  frc::PWMSparkMax m_rearRight{kRearRightChannel};
  frc::MecanumDrive m_robotDrive{
      [&](double output) { m_frontLeft.Set(output); },
      [&](double output) { m_rearLeft.Set(output); },
      [&](double output) { m_frontRight.Set(output); },
      [&](double output) { m_rearRight.Set(output); }};

  void RobotInit() override {
    // Invert the right side motors. You may need to change or remove this to
    // match your robot.
    m_frontRight.SetInverted(true);
    m_rearRight.SetInverted(true);
  }

PYTHON

    # Channels on the roboRIO that the motor controllers are plugged in to
    kFrontLeftChannel = 2
    kRearLeftChannel = 3
    kFrontRightChannel = 1
    kRearRightChannel = 0

    def robotInit(self):
        self.frontLeft = wpilib.PWMSparkMax(self.kFrontLeftChannel)
        self.rearLeft = wpilib.PWMSparkMax(self.kRearLeftChannel)
        self.frontRight = wpilib.PWMSparkMax(self.kFrontRightChannel)
        self.rearRight = wpilib.PWMSparkMax(self.kRearRightChannel)

        # invert the right side motors
        # you may need to change or remove this to match your robot
        self.frontRight.setInverted(True)
        self.rearRight.setInverted(True)

        self.robotDrive = wpilib.drive.MecanumDrive(
            self.frontLeft, self.rearLeft, self.frontRight, self.rearRight
        )

        self.stick = wpilib.Joystick(self.kJoystickChannel)

Modes d’entraînement Mécanum

Note

Les conventions d’axe d’entraînement sont différentes des conventions d’axe de joystick courantes. Voir les Conventions d’axe ci-dessus pour plus d’informations.

La classe MecanumDrive contient deux différents modes de pilotage (par défaut)

driveCartesian: Les angles sont mesurés dans le sens horaire à partir de l’axe X positif. La vitesse du robot est indépendante de son angle ou de sa vitesse de rotation.

drivePolar: Les angles sont mesurés dans le sens antihoraire à partir de la ligne droite. La vitesse à laquelle le robot roule (translation) est indépendante de son angle ou de sa vitesse de rotation.

JAVA

public void teleopPeriodic() {
    // Drive using the X, Y, and Z axes of the joystick.
    m_robotDrive.driveCartesian(-m_stick.getY(), -m_stick.getX(), -m_stick.getZ());
    // Drive at 45 degrees relative to the robot, at the speed given by the Y axis of the joystick, with no rotation.
    m_robotDrive.drivePolar(-m_stick.getY(), Rotation2d.fromDegrees(45), 0);
}

C++

void TeleopPeriodic() override {
    // Drive using the X, Y, and Z axes of the joystick.
    m_robotDrive.driveCartesian(-m_stick.GetY(), -m_stick.GetX(), -m_stick.GetZ());
    // Drive at 45 degrees relative to the robot, at the speed given by the Y axis of the joystick, with no rotation.
    m_robotDrive.drivePolar(-m_stick.GetY(), 45_deg, 0);
}

PYTHON

def teleopPeriodic(self):
    // Drive using the X, Y, and Z axes of the joystick.
    self.robotDrive.driveCartesian(-self.stick.getY(), -self.stick.getX(), -self.stick.getZ())
    // Drive at 45 degrees relative to the robot, at the speed given by the Y axis of the joystick, with no rotation.
    self.robotDrive.drivePolar(-self.stick.getY(), Rotation2d.fromDegrees(45), 0)

Conduite orientée sur le terrain

Un 4ème paramètre peut être fourni à la méthode driveCartesian (double ySpeed, double xSpeed, double zRotation, double gyroAngle), soit l’angle renvoyé par un capteur gyroscopique. Cela ajustera la valeur de rotation fournie. Ceci est particulièrement utile avec le Mécanum car, aux fins de la direction, le robot n’a vraiment ni avant, ni arrière, ni côtés. Il peut aller dans n’importe quelle direction. L’ajout de l’angle en degrés par rapport à un objet gyroscopique entraînera le robot à s’éloigner des pilotes lorsque le joystick est poussé vers l’avant et vers les pilotes lorsqu’il est tiré vers eux, quelle que soit la direction dans laquelle le robot fait face.

L’utilisation de la conduite orientée sur le terrain rend souvent le robot beaucoup plus facile à conduire, en particulier par rapport à un système d’entraînement « orienté robot » où les commandes sont inversées lorsque le robot fait face aux conducteurs.

N’oubliez pas d’obtenir l’angle gyroscopique chaque fois que la méthode driveCartesian() est appelée.

Note

Beaucoup d’équipes aiment aussi augmenter linéairement les entrées des joysticks au fil du temps pour avoir une accélération en douceur et réduire le jerk. Ceci peut être accompli avec un Slew Rate Limiter.

Utilisation des classes WPILib pour piloter votre robot

Transmissions standard

Robots à entraînement différentiel

Entraînement de type Mécanum

Conventions utilisées par les classes

Motor Inversion

Squaring Inputs

Input Deadband

Maximum Output

La sécurité moteur (Motor Safety)

Conventions des axes

Utilisation de la classe DifferentialDrive pour contrôler les robots à entraînement différentiel (WCD)

Multi-Motor DifferentialDrive

Modes de conduite

Utilisation de la classe MecanumDrive pour contrôler les robots avec trains d’entraînement Mécanum

Modes d’entraînement Mécanum

Conduite orientée sur le terrain