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

Ce guide comprend des exemples de code qui impliquent le matériel du fournisseur pour la commodité de l’utilisateur. Dans ce document, PWM fait référence au contrôleur de moteur inclus dans le KOP. L’onglet CTRE fait référence au contrôleur de moteur Talon FX (moteur Falcon 500), mais l’utilisation est similaire pour TalonSRX et VictorSPX. L’onglet REV fait référence au CAN SPARK MAX contrôlant un moteur sans balais, mais il est similaire pour un moteur à balais. On suppose que l’utilisateur a déjà installé le :doc:`vendordeps ` requis et configuré le(s) périphérique(s) (mettre à jour le micrologiciel, attribuer des ID CAN, etc.) conformément à la documentation du fabricant (`CTRE <https://docs. ctr-electronics.com/>`__ 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 VM is configured to automatically run this class, and to call the functions 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();

  public Robot() {
    SendableRegistry.addChild(m_robotDrive, m_leftDrive);
    SendableRegistry.addChild(m_robotDrive, m_rightDrive);
  }

  /**
   * This function is run when the robot is first started up and should be used for any
   * initialization code.
   */
  @Override
  public void robotInit() {
    // 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

JAVA

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

C++

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

PYTHON

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

REV

JAVA

import com.revrobotics.CANSparkMax;
import com.revrobotics.CANSparkMaxLowLevel.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

Notre code doit référencer les composants de WPILib qui sont utilisés. Cela se fait en utilisant les instructions #include (en C++) ou import (en Java). Le programme fait référence aux classes pour Joystick (pour le pilotage), PWMSparkMax / WPI_TalonFX / CANSparkMax (pour la commande des moteurs), ``TimedRobot (la classe de base utilisée pour l’exemple) , Timer (utilisé pour le mode autonome) et DifferentialDrive (pour connecter la commande par joystick aux moteurs).

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++

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
  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

Java

public class Robot extends TimedRobot {
   private final WPI_TalonFX m_leftDrive = new WPI_TalonFX(1);
   private final WPI_TalonFX m_rightDrive = new WPI_TalonFX(2);
   private final DifferentialDrive m_robotDrive = new DifferentialDrive(m_leftDrive, m_rightDrive);
   private final Joystick m_stick = new Joystick(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_TalonFX m_left{1};
 ctre::phoenix::motorcontrol::can::WPI_TalonFX m_right{2};
 frc::DifferentialDrive m_robotDrive{m_left, m_right};

 frc::Joystick m_stick{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)

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, m_rightDrive);
  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{m_left, m_right};

 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)

Le robot de nos exemples a un joystick branché au port USB 0 pour le mode Arcade drive et deux moteurs branchés aux ports PWM 0 et 1 (les exemples des tierces parties utilisent CAN avec les ID 1 et 2). Ici nous créons des objets de type DifferentialDrive(m_robotDrive), Joystick(m_stick) et Timer(m_timer). Cette section du code accomplit trois choses:

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

  @Override
  public void robotInit() {
    // 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++

void RobotInit() {}

Python

def robotInit(self):

La méthode « RobotInit » est exécutée lorsque le programme du robot démarre, mais après le constructeur. Le « RobotInit » de notre programme d’exemple inverse le côté droit du groupe motopropulseur. Selon votre configuration de conduite, vous devrez peut-être inverser le côté gauche à la place.

Note

En C++, l’inversion du moteur est gérée dans le constructeur Robot() ci-dessus.

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()
        )

Comme dans le mode Autonomous, le mode Teleop possède les fonctions TeleopInit et TeleopPeriodic. Dans cet exemple, nous n’avons rien à faire dans TeleopInit, qui est fourni uniquement à des fins d’illustration. Dans TeleopPeriodic, le code utilise la méthode ArcadeDrive pour faire correspondre l’axe Y du Joystick au mouvement rectiligne avancer/reculer des moteurs d’entraînement et l’axe X pour le mouvement de rotation.

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