Création de votre programme test Drivetrain (Java/C++/Python)

Une fois que tout est installé, nous sommes prêts à créer un programme de robot. WPILib est livré avec plusieurs modèles pour les programmes de robots. L’utilisation de ces modèles est fortement recommandée pour les nouveaux utilisateurs; cependant, les utilisateurs avancés sont libres d’écrire leur propre code robot à partir de zéro. Cet article explore la création d’un projet à partir de l’un des exemples fournis qui a un certain code déjà écrit pour piloter un robot de base.

• Création d’un nouveau projet WPILib (Java/C++)

• Création d’un nouveau projet WPILib (Python)

Important

This guide includes code examples that involve vendor hardware for the convenience of the user. In this document, PWM refers to the motor controller included in the KOP. The CTRE tab references the Talon FX motor controller (Falcon 500 motor), but usage is similar for TalonSRX and VictorSPX. The REV tab references the CAN SPARK MAX controlling a brushless motor, but it’s similar for brushed motor. There is an assumption that the user has already installed the required vendordeps and configured the device(s) (update firmware, assign CAN IDs, etc) according to the manufacturer documentation (CTRE REV).

Création d’un nouveau projet WPILib (Java/C++)

Affichez la palette de commandes de Visual Studio Code avec Ctrl+Shift+P. Ensuite, tapez « WPILib » dans l’invite. Étant donné que toutes les commandes WPILib commencent par « WPILib », cela affichera la liste des commandes VS Code spécifiques à WPILib. Maintenant, sélectionnez la commande « Créer un nouveau projet »:

Cette opération fera apparaître la fenêtre « New Project Creator Window »:

Les éléments de la fenêtre New Project Creator sont expliqués ci-dessous :

1. Project Type: Le genre de projet que nous voulons créer. Pour cet exemple, sélectionnez Example

2. Language: C’est le langage de programmation (C++ ou Java) qui sera utilisé pour ce projet.

3. Project Base: Cette zone est utilisée pour sélectionner la classe de base ou l’exemple à utiliser comme source pour générer le projet. Pour cet exemple, sélectionnez Getting Started

4. Base Folder: Ce paramètre détermine le dossier dans lequel le projet de robot sera situé.

5. Project Name: Le nom du projet de robot. Ce paramètre spécifie également le nom du dossier de projet si la zone Create New Folder est cochée.

6. Create a New Folder: Si cette case est cochée, un nouveau dossier sera créé pour contenir le projet dans le dossier précédemment spécifié. Si elle n’est pas cochée, le projet sera situé directement dans le dossier précédemment spécifié. Une erreur sera générée si le dossier n’est pas vide et que cette case n’est pas cochée. Un dossier de projet sera créé si la case Create New Folder est cochée.

7. Team Number: Numéro d’équipe du projet, qui sera utilisé pour les noms de packages dans le projet et pour localiser le robot au moment du déploiement du code.

8. Enable Desktop Support: Permet de faire le test unitaire et la simulation. Bien que WPILib prenne en charge cette fonctionnalité, pour les bibliothèques de logiciels tiers cette prise en charge n’est pas garantie. Si les bibliothèques logicielles ne prennent pas en charge les applications de bureau, votre code peut ne pas compiler ou planter. Cette case doit être laissée non cochée à moins que des tests unitaires ou une simulation ne soient nécessaires et que toutes les bibliothèques de logiciels le prennent en charge. Pour cet exemple, ne cochez pas cette case.

Une fois que tout ce qui précède a été configuré, cliquez sur « Generate Project » et le projet robot sera créé.

Note

Toutes les erreurs lors de la génération de projet apparaîtront dans le coin inférieur droit de l’écran.

Avertissement

La création de projets sur OneDrive n’est pas prise en charge car la mise en cache de OneDrive interfère avec le système de build. Certaines installations Windows placent par défaut les dossiers Documents et Bureau sur OneDrive.

Ouverture du nouveau projet

Après avoir réussi à créer votre projet, VS Code vous donnera la possibilité d’ouvrir le projet comme indiqué ci-dessus. Nous pouvons choisir de le faire maintenant ou plus tard en tapant Ctrl+K puis Ctrl+O (ou simplement Command+O sur macOS) et sélectionner le dossier où nous avons enregistré notre projet.

Cliquez sur Yes I trust the authors. (Oui, je fais confiance aux auteurs.)

Une fois ouvert, nous pouvons voir la hiérarchie du projet à gauche. En double-cliquant sur un fichier, on ouvre ce fichier dans l’éditeur.

Configurations C++ (C++ uniquement)

Pour les projets C++, il y a une étape de plus pour configurer IntelliSense. Chaque fois que nous ouvrons un projet, nous devrions obtenir un pop-up dans le coin inférieur droit demandant de rafraîchir les configurations C++. Cliquez sur « Yes » pour configurer IntelliSense.

Création d’un nouveau projet WPILib (Python)

Exécuter la commande robotpy init initialisera un nouveau projet de robot.

Pour Windows

py -3 -m robotpy init

Pour macOS

python3 -m robotpy init

Pour Linux

python3 -m robotpy init

Cela créera un fichier robot.py et pyproject.toml, mais n’écrasera pas un fichier existant.

• Le fichier pyproject.toml contient les exigences pour votre projet, qui sont téléchargées et installées via la commande robotpy sync.

• Le fichier robot.py est l’endroit où vous mettrez votre classe Robot.

Voir aussi

docs/zero-to-robot/step-2/python-setup:Téléchargement de RobotPy pour roboRIO

Exemple de transmission de base

Tout d’abord, voici à quoi peut ressembler un code simple pour une transmission avec des moteurs contrôlés par PWM (tels que SparkMax).

Note

l’exemple Python ci-dessous provient de https://github.com/robotpy/examples/tree/main/GettingStarted

JAVA

// Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.

package edu.wpi.first.wpilibj.examples.gettingstarted;

import edu.wpi.first.util.sendable.SendableRegistry;
import edu.wpi.first.wpilibj.TimedRobot;
import edu.wpi.first.wpilibj.Timer;
import edu.wpi.first.wpilibj.XboxController;
import edu.wpi.first.wpilibj.drive.DifferentialDrive;
import edu.wpi.first.wpilibj.motorcontrol.PWMSparkMax;

/**
 * The methods in this class are called automatically corresponding to each mode, as described in
 * the TimedRobot documentation. If you change the name of this class or the package after creating
 * this project, you must also update the manifest file in the resource directory.
 */
public class Robot extends TimedRobot {
  private final PWMSparkMax m_leftDrive = new PWMSparkMax(0);
  private final PWMSparkMax m_rightDrive = new PWMSparkMax(1);
  private final DifferentialDrive m_robotDrive =
      new DifferentialDrive(m_leftDrive::set, m_rightDrive::set);
  private final XboxController m_controller = new XboxController(0);
  private final Timer m_timer = new Timer();

  /** Called once at the beginning of the robot program. */
  public Robot() {
    SendableRegistry.addChild(m_robotDrive, m_leftDrive);
    SendableRegistry.addChild(m_robotDrive, m_rightDrive);

    // We need to invert one side of the drivetrain so that positive voltages
    // result in both sides moving forward. Depending on how your robot's
    // gearbox is constructed, you might have to invert the left side instead.
    m_rightDrive.setInverted(true);
  }

  /** This function is run once each time the robot enters autonomous mode. */
  @Override
  public void autonomousInit() {
    m_timer.restart();
  }

  /** This function is called periodically during autonomous. */
  @Override
  public void autonomousPeriodic() {
    // Drive for 2 seconds
    if (m_timer.get() < 2.0) {
      // Drive forwards half speed, make sure to turn input squaring off
      m_robotDrive.arcadeDrive(0.5, 0.0, false);
    } else {
      m_robotDrive.stopMotor(); // stop robot
    }
  }

  /** This function is called once each time the robot enters teleoperated mode. */
  @Override
  public void teleopInit() {}

  /** This function is called periodically during teleoperated mode. */
  @Override
  public void teleopPeriodic() {
    m_robotDrive.arcadeDrive(-m_controller.getLeftY(), -m_controller.getRightX());
  }

  /** This function is called once each time the robot enters test mode. */
  @Override
  public void testInit() {}

  /** This function is called periodically during test mode. */
  @Override
  public void testPeriodic() {}
}

C++

// Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.

#include <frc/TimedRobot.h>
#include <frc/Timer.h>
#include <frc/XboxController.h>
#include <frc/drive/DifferentialDrive.h>
#include <frc/motorcontrol/PWMSparkMax.h>

class Robot : public frc::TimedRobot {
 public:
  Robot() {
    wpi::SendableRegistry::AddChild(&m_robotDrive, &m_left);
    wpi::SendableRegistry::AddChild(&m_robotDrive, &m_right);

    // We need to invert one side of the drivetrain so that positive voltages
    // result in both sides moving forward. Depending on how your robot's
    // gearbox is constructed, you might have to invert the left side instead.
    m_right.SetInverted(true);
    m_robotDrive.SetExpiration(100_ms);
    m_timer.Start();
  }

  void AutonomousInit() override { m_timer.Restart(); }

  void AutonomousPeriodic() override {
    // Drive for 2 seconds
    if (m_timer.Get() < 2_s) {
      // Drive forwards half speed, make sure to turn input squaring off
      m_robotDrive.ArcadeDrive(0.5, 0.0, false);
    } else {
      // Stop robot
      m_robotDrive.ArcadeDrive(0.0, 0.0, false);
    }
  }

  void TeleopInit() override {}

  void TeleopPeriodic() override {
    // Drive with arcade style (use right stick to steer)
    m_robotDrive.ArcadeDrive(-m_controller.GetLeftY(),
                             m_controller.GetRightX());
  }

  void TestInit() override {}

  void TestPeriodic() override {}

 private:
  // Robot drive system
  frc::PWMSparkMax m_left{0};
  frc::PWMSparkMax m_right{1};
  frc::DifferentialDrive m_robotDrive{
      [&](double output) { m_left.Set(output); },
      [&](double output) { m_right.Set(output); }};

  frc::XboxController m_controller{0};
  frc::Timer m_timer;
};

#ifndef RUNNING_FRC_TESTS
int main() {
  return frc::StartRobot<Robot>();
}
#endif

PYTHON

#!/usr/bin/env python3
#
# Copyright (c) FIRST and other WPILib contributors.
# Open Source Software; you can modify and/or share it under the terms of
# the WPILib BSD license file in the root directory of this project.
#

import wpilib
import wpilib.drive


class MyRobot(wpilib.TimedRobot):
    def robotInit(self):
        """
        This function is called upon program startup and
        should be used for any initialization code.
        """
        self.leftDrive = wpilib.PWMSparkMax(0)
        self.rightDrive = wpilib.PWMSparkMax(1)
        self.robotDrive = wpilib.drive.DifferentialDrive(
            self.leftDrive, self.rightDrive
        )
        self.controller = wpilib.XboxController(0)
        self.timer = wpilib.Timer()

        # We need to invert one side of the drivetrain so that positive voltages
        # result in both sides moving forward. Depending on how your robot's
        # gearbox is constructed, you might have to invert the left side instead.
        self.rightDrive.setInverted(True)

    def autonomousInit(self):
        """This function is run once each time the robot enters autonomous mode."""
        self.timer.restart()

    def autonomousPeriodic(self):
        """This function is called periodically during autonomous."""

        # Drive for two seconds
        if self.timer.get() < 2.0:
            # Drive forwards half speed, make sure to turn input squaring off
            self.robotDrive.arcadeDrive(0.5, 0, squareInputs=False)
        else:
            self.robotDrive.stopMotor()  # Stop robot

    def teleopInit(self):
        """This function is called once each time the robot enters teleoperated mode."""

    def teleopPeriodic(self):
        """This function is called periodically during teleoperated mode."""
        self.robotDrive.arcadeDrive(
            -self.controller.getLeftY(), -self.controller.getRightX()
        )

    def testInit(self):
        """This function is called once each time the robot enters test mode."""

    def testPeriodic(self):
        """This function is called periodically during test mode."""


if __name__ == "__main__":
    wpilib.run(MyRobot)

Examinons maintenant différentes parties du code.

Imports/Includes

PWM

Java

import edu.wpi.first.util.sendable.SendableRegistry;
import edu.wpi.first.wpilibj.TimedRobot;
import edu.wpi.first.wpilibj.Timer;
import edu.wpi.first.wpilibj.XboxController;
import edu.wpi.first.wpilibj.drive.DifferentialDrive;
import edu.wpi.first.wpilibj.motorcontrol.PWMSparkMax;

C++

#include <frc/TimedRobot.h>
#include <frc/Timer.h>
#include <frc/XboxController.h>
#include <frc/drive/DifferentialDrive.h>
#include <frc/motorcontrol/PWMSparkMax.h>

Python

import wpilib
import wpilib.drive

CTRE-Phoenix6

JAVA

import edu.wpi.first.wpilibj.TimedRobot;
import edu.wpi.first.wpilibj.Timer;
import edu.wpi.first.wpilibj.XboxController;
import edu.wpi.first.wpilibj.drive.DifferentialDrive;
import com.ctre.phoenix6.hardware.TalonFX;

C++

#include <frc/TimedRobot.h>
#include <frc/Timer.h>
#include <frc/XboxController.h>
#include <frc/drive/DifferentialDrive.h>
#include <ctre/phoenix6/TalonFX.hpp>

PYTHON

import wpilib               # Used to get the joysticks
import wpilib.drive         # Used for the DifferentialDrive class
import phoenix6             # CTRE library

REV

JAVA

import com.revrobotics.CANSparkMax;
import com.revrobotics.CANSparkLowLevel.MotorType;
import edu.wpi.first.wpilibj.TimedRobot;
import edu.wpi.first.wpilibj.Timer;
import edu.wpi.first.wpilibj.XboxController;
import edu.wpi.first.wpilibj.drive.DifferentialDrive;

C++

#include <frc/TimedRobot.h>
#include <frc/Timer.h>
#include <frc/XboxController.h>
#include <frc/drive/DifferentialDrive.h>
#include <frc/motorcontrol/PWMSparkMax.h>
#include <rev/CANSparkMax.h>

PYTHON

import wpilib           # Used to get the joysticks
import wpilib.drive     # Used for the DifferentialDrive class
import rev              # REV library

CTRE-Phoenix5

JAVA

import edu.wpi.first.wpilibj.TimedRobot;
import edu.wpi.first.wpilibj.Timer;
import edu.wpi.first.wpilibj.XboxController;
import edu.wpi.first.wpilibj.drive.DifferentialDrive;
import com.ctre.phoenix.motorcontrol.can.WPI_TalonSRX;

C++

#include <frc/TimedRobot.h>
#include <frc/Timer.h>
#include <frc/XboxController.h>
#include <frc/drive/DifferentialDrive.h>
#include <ctre/phoenix/motorcontrol/can/WPI_TalonSRX.h>

PYTHON

import wpilib           # Used to get the joysticks
import wpilib.drive     # Used for the DifferentialDrive class
import ctre             # CTRE library

Our code needs to reference the components of WPILib that are used. In C++ this is accomplished using #include statements; in Java and Python it is done with import statements. The program references classes for XBoxController (for driving), PWMSparkMax / TalonFX / CANSparkMax / WPI_TalonSRX (for controlling motors), TimedRobot (the base class used for the example), Timer (used for autonomous), and DifferentialDrive (for connecting the Xbox controller to the motors).

Définition des variables de notre prototype de robot

PWM

Java

public class Robot extends TimedRobot {
  private final PWMSparkMax m_leftDrive = new PWMSparkMax(0);
  private final PWMSparkMax m_rightDrive = new PWMSparkMax(1);
  private final DifferentialDrive m_robotDrive =
      new DifferentialDrive(m_leftDrive::set, m_rightDrive::set);
  private final XboxController m_controller = new XboxController(0);
  private final Timer m_timer = new Timer();

C++

 private:
  // Robot drive system
  frc::PWMSparkMax m_left{0};
  frc::PWMSparkMax m_right{1};
  frc::DifferentialDrive m_robotDrive{
      [&](double output) { m_left.Set(output); },
      [&](double output) { m_right.Set(output); }};

  frc::XboxController m_controller{0};
  frc::Timer m_timer;
};

Python

class MyRobot(wpilib.TimedRobot):
    def robotInit(self):
        """
        This function is called upon program startup and
        should be used for any initialization code.
        """
        self.leftDrive = wpilib.PWMSparkMax(0)
        self.rightDrive = wpilib.PWMSparkMax(1)
        self.robotDrive = wpilib.drive.DifferentialDrive(
            self.leftDrive, self.rightDrive
        )
        self.controller = wpilib.XboxController(0)
        self.timer = wpilib.Timer()

        # We need to invert one side of the drivetrain so that positive voltages
        # result in both sides moving forward. Depending on how your robot's
        # gearbox is constructed, you might have to invert the left side instead.
        self.rightDrive.setInverted(True)

CTRE-Phoenix6

Java

public class Robot extends TimedRobot {
   private final TalonFX m_leftDrive = new TalonFX(1);
   private final TalonFX m_rightDrive = new TalonFX(2);
   private final DifferentialDrive m_robotDrive =
     new DifferentialDrive(m_leftDrive::set, m_rightDrive::set);
   private final XboxController m_controller = new XboxController(0);
   private final Timer m_timer = new Timer();

C++

public:
 Robot() {

    // We need to invert one side of the drivetrain so that positive voltages
    // result in both sides moving forward. Depending on how your robot's
    // gearbox is constructed, you might have to invert the left side instead.
    m_right.SetInverted(true);
    m_robotDrive.SetExpiration(100_ms);
    m_timer.Start();
  }

private:
 // Robot drive system
 ctre::phoenix6::hardware::TalonFX m_left{1};
 ctre::phoenix6::hardware::TalonFX m_right{2};
 frc::DifferentialDrive m_robotDrive{
   [&](double output) { m_left.Set(output); },
   [&](double output) { m_right.Set(output); }};
 frc::XboxController m_controller{0};
 frc::Timer m_timer;

Python

class MyRobot(wpilib.TimedRobot):
  def robotInit(self):
     """
     This function is called upon program startup and
     should be used for any initialization code.
     """
     self.leftDrive = phoenix6.hardware.TalonFX(1)
     self.rightDrive = phoenix6.hardware.TalonFX(2)
     self.robotDrive = wpilib.drive.DifferentialDrive(
         self.leftDrive, self.rightDrive
     )
     self.controller = wpilib.XboxController(0)
     self.timer = wpilib.Timer()
     # We need to invert one side of the drivetrain so that positive voltages
     # result in both sides moving forward. Depending on how your robot's
     # gearbox is constructed, you might have to invert the left side instead.
     self.rightDrive.setInverted(True)

REV

Java

public class Robot extends TimedRobot {
  private final CANSparkMax m_leftDrive = new CANSparkMax(1, MotorType.kBrushless);
  private final CANSparkMax m_rightDrive = new CANSparkMax(2, MotorType.kBrushless);
  private final DifferentialDrive m_robotDrive =
    new DifferentialDrive(m_leftDrive::set, m_rightDrive::set);
  private final XboxController m_controller = new XboxController(0);
  private final Timer m_timer = new Timer();

C++

public:
 Robot() {

    // We need to invert one side of the drivetrain so that positive voltages
    // result in both sides moving forward. Depending on how your robot's
    // gearbox is constructed, you might have to invert the left side instead.
    m_right.SetInverted(true);
    m_robotDrive.SetExpiration(100_ms);
    m_timer.Start();
  }

private:
 // Robot drive system
 rev::CANSparkMax m_left{1, rev::CANSparkMax::MotorType::kBrushless};
 rev::CANSparkMax m_right{2, rev::CANSparkMax::MotorType::kBrushless};
 frc::DifferentialDrive m_robotDrive{
   [&](double output) { m_left.Set(output); },
   [&](double output) { m_right.Set(output); }};
 frc::XboxController m_controller{0};
 frc::Timer m_timer;

Python

class MyRobot(wpilib.TimedRobot):
    def robotInit(self):
        """
        This function is called upon program startup and
        should be used for any initialization code.
        """
        self.leftDrive = rev.CANSparkMax(1, rev.CANSparkMax.MotorType.kBrushless)
        self.rightDrive = rev.CANSparkMax(2, rev.CANSparkMax.MotorType.kBrushless)
        self.robotDrive = wpilib.drive.DifferentialDrive(
            self.leftDrive, self.rightDrive
        )
        self.controller = wpilib.XboxController(0)
        self.timer = wpilib.Timer()

        # We need to invert one side of the drivetrain so that positive voltages
        # result in both sides moving forward. Depending on how your robot's
        # gearbox is constructed, you might have to invert the left side instead.
        self.rightDrive.setInverted(True)

CTRE-Phoenix5

Java

public class Robot extends TimedRobot {
   private final WPI_TalonSRX m_leftDrive = new WPI_TalonSRX(1);
   private final WPI_TalonSRX m_rightDrive = new WPI_TalonSRX(2);
   private final DifferentialDrive m_robotDrive = new DifferentialDrive(m_leftDrive1::set, m_rightDrive2::set);
   private final XboxController m_controller = new XboxController(0);
   private final Timer m_timer = new Timer();

C++

public:
 Robot() {

    // We need to invert one side of the drivetrain so that positive voltages
    // result in both sides moving forward. Depending on how your robot's
    // gearbox is constructed, you might have to invert the left side instead.
    m_right.SetInverted(true);
    m_robotDrive.SetExpiration(100_ms);
    m_timer.Start();
  }

private:
 // Robot drive system
 ctre::phoenix::motorcontrol::can::WPI_TalonSRX m_left{1};
 ctre::phoenix::motorcontrol::can::WPI_TalonSRX m_right{2};
 frc::DifferentialDrive m_robotDrive{
   [&](double output) { m_left.Set(output); },
   [&](double output) { m_right.Set(output); }};
 frc::XboxController m_controller{0};
 frc::Timer m_timer;

Python

class MyRobot(wpilib.TimedRobot):
    def robotInit(self):
        """
        This function is called upon program startup and
        should be used for any initialization code.
        """
        self.leftDrive = ctre.WPI_TalonFX(1)
        self.rightDrive = ctre.WPI_TalonFX(2)
        self.robotDrive = wpilib.drive.DifferentialDrive(
            self.leftDrive, self.rightDrive
        )
        self.controller = wpilib.XboxController(0)
        self.timer = wpilib.Timer()

        # We need to invert one side of the drivetrain so that positive voltages
        # result in both sides moving forward. Depending on how your robot's
        # gearbox is constructed, you might have to invert the left side instead.
        self.rightDrive.setInverted(True)

The sample robot in our examples will have an Xbox Controller on USB port 0 for arcade drive and two motors on PWM ports 0 and 1 (Vendor examples use CAN with IDs 1 and 2). Here we create objects of type DifferentialDrive (m_robotDrive), XboxController (m_controller) and Timer (m_timer). This section of the code does three things:

1. Définit les variables en tant que membres de notre classe Robot.

2. Initialise les variables.

Note

L’initialisation des variables en C++ se trouve dans la section private en bas du programme. Cela signifie qu’elles sont privées à la classe Robot. Le code C++ configure également le paramètre Motor Safety expiration à 0,1 seconde (le déplacement s’arrêtera si nous ne lui donnons pas une commande à toutes les 0,1 secondes) et démarre le Timer utilisé pour le mode autonome.

Initialisation du robot

Java

  /** Called once at the beginning of the robot program. */
  public Robot() {
    // We need to invert one side of the drivetrain so that positive voltages
    // result in both sides moving forward. Depending on how your robot's
    // gearbox is constructed, you might have to invert the left side instead.
    m_rightDrive.setInverted(true);
  }

C++

public:
 Robot() {
   // We need to invert one side of the drivetrain so that positive voltages
   // result in both sides moving forward. Depending on how your robot's
   // gearbox is constructed, you might have to invert the left side instead.
   m_right.SetInverted(true);
   m_robotDrive.SetExpiration(100_ms);
   m_timer.Start();
 }

Python

def robotInit(self):

The Robot constructor for our sample program inverts the right side of the drivetrain. Depending on your drive setup, you might need to invert the left side instead.

Exemple de mode autonome simple

JAVA

  /** This function is run once each time the robot enters autonomous mode. */
  @Override
  public void autonomousInit() {
    m_timer.restart();
  }

  /** This function is called periodically during autonomous. */
  @Override
  public void autonomousPeriodic() {
    // Drive for 2 seconds
    if (m_timer.get() < 2.0) {
      // Drive forwards half speed, make sure to turn input squaring off
      m_robotDrive.arcadeDrive(0.5, 0.0, false);
    } else {
      m_robotDrive.stopMotor(); // stop robot
    }
  }

C++

  void AutonomousInit() override { m_timer.Restart(); }

  void AutonomousPeriodic() override {
    // Drive for 2 seconds
    if (m_timer.Get() < 2_s) {
      // Drive forwards half speed, make sure to turn input squaring off
      m_robotDrive.ArcadeDrive(0.5, 0.0, false);
    } else {
      // Stop robot
      m_robotDrive.ArcadeDrive(0.0, 0.0, false);
    }
  }

PYTHON

    def autonomousInit(self):
        """This function is run once each time the robot enters autonomous mode."""
        self.timer.restart()

    def autonomousPeriodic(self):
        """This function is called periodically during autonomous."""

        # Drive for two seconds
        if self.timer.get() < 2.0:
            # Drive forwards half speed, make sure to turn input squaring off
            self.robotDrive.arcadeDrive(0.5, 0, squareInputs=False)
        else:
            self.robotDrive.stopMotor()  # Stop robot

La méthode AutonomousInit est exécutée une seule fois au moment où le robot passe au mode autonomie à partir d’un autre mode. Dans le programme, nous redémarrons le Timer dans cette méthode.

AutonomousPeriodic est exécuté une fois par période lorsque que le robot est en mode autonome. Dans la classe TimedRobot la période est de durée fixe et par défaut est égale à 20ms. Dans cet exemple, le code périodique vérifie si la minuterie est inférieure à 2 secondes et, dans ce cas, fait avancer le robot à mi-vitesse à l’aide de la méthode ArcadeDrive de la classe DifferentialDrive. S’il s’est écoulé plus de 2 secondes, le code met fin au déplacement du robot.

Contrôle par Joystick pendant le mode téléopéré

JAVA

  /** This function is called once each time the robot enters teleoperated mode. */
  @Override
  public void teleopInit() {}

  /** This function is called periodically during teleoperated mode. */
  @Override
  public void teleopPeriodic() {
    m_robotDrive.arcadeDrive(-m_controller.getLeftY(), -m_controller.getRightX());
  }

C++

  void TeleopInit() override {}

  void TeleopPeriodic() override {
    // Drive with arcade style (use right stick to steer)
    m_robotDrive.ArcadeDrive(-m_controller.GetLeftY(),
                             m_controller.GetRightX());
  }

PYTHON

    def teleopInit(self):
        """This function is called once each time the robot enters teleoperated mode."""

    def teleopPeriodic(self):
        """This function is called periodically during teleoperated mode."""
        self.robotDrive.arcadeDrive(
            -self.controller.getLeftY(), -self.controller.getRightX()
        )

Like in Autonomous, the Teleop mode has a TeleopInit and TeleopPeriodic function. In this example we don’t have anything to do in TeleopInit, it is provided for illustration purposes only. In TeleopPeriodic, the code uses the ArcadeDrive method to map the Y-axis of the left thumbstick of the XBoxController to forward/back motion of the drive motors and the X-axis to turning motion.

Mode test

JAVA

  /** This function is called once each time the robot enters test mode. */
  @Override
  public void testInit() {}

  /** This function is called periodically during test mode. */
  @Override
  public void testPeriodic() {}
}

C++

  void TestInit() override {}

  void TestPeriodic() override {}

PYTHON

    def testInit(self):
        """This function is called once each time the robot enters test mode."""

    def testPeriodic(self):
        """This function is called periodically during test mode."""

Le mode test est utilisé afin de tester la fonctionnalité du robot. À l’instar de TeleopInit, les méthodes TestInit et TestPeriodic sont fournies ici uniquement à des fins d’illustration.

Déploiement du code projet sur un robot

• Compilation et déploiement du code Java/C++ du robot

• Déploiement du code Python