Creating your Test Drivetrain Program (Java/C++/Python)

Once everything is installed, we’re ready to create a robot program. WPILib comes with several templates for robot programs. Use of these templates is highly recommended for new users; however, advanced users are free to write their own robot code from scratch. This article walks through creating a project from one of the provided examples which has some code already written to drive a basic robot.

• Creating a New WPILib Project (Java/C++)

• Creating a New WPILib Project (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).

Creating a New WPILib Project (Java/C++)

In Visual Studio Code, click the WPILib logo in the top right to launch the WPILib Command Palette. Select Create a new project:

This will bring up the “WPILIb New Project Creator”

The Project Type chooses between an empty template project, or a WPILib example project. For this example, select Example and then choose Next.

This will bring up the language and base selection window.

1. Language: This is the language (C++ or Java) that will be used for this project.

2. Project Base: This box is used to select the base class or example to generate the project from. For this example, select Getting Started

After making the selections, click Next.

This will bring up the Project and Configuration window.

1. Base Folder: This determines the folder in which the robot project will be located.

2. Project Name: The name of the robot project. This also specifies the name that the project folder will be given if the Create New Folder box is checked.

3. Create a New Folder: If this is checked, a new folder will be created to hold the project within the previously-specified folder. If it is not checked, the project will be located directly in the previously-specified folder. An error will be thrown if the folder is not empty and this is not checked.

4. Team Number: The team number for the project, which will be used for package names within the project and to locate the robot when deploying code.

5. Enable Desktop Support: Enables unit test and simulation support (see Introduction to Robot Simulation). While WPILib supports this, third party software libraries may not. If libraries do not support desktop, then your code may not compile or may crash. It should be left unchecked unless unit testing or simulation is needed and all libraries support it. For this example, do not check this box.

Warning

Creating projects on OneDrive is not supported as OneDrive’s caching interferes with the build system. Some Windows installations put the Documents and Desktop folders on OneDrive by default.

Once all the above have been configured, click Next.

This will bring up the Review and Create window.

Double check all the settings and click Create Project. If anything is not correct, click Back and make the necessary corrections.

Note

Any errors in project generation will appear in the bottom right-hand corner of the screen.

Opening The New Project

After successfully creating your project, VS Code will give the option of opening the project as shown above. We can choose to do that now or later by typing Ctrl+K then Ctrl+O (or just Command+O on macOS) and select the folder where we saved our project.

Click Yes I trust the authors.

Once opened we will see the project hierarchy on the left. Double clicking on the file will open that file in the editor.

C++ Configurations (C++ Only)

For C++ projects, there is one more step to set up IntelliSense. Whenever we open a project, we should get a pop-up in the bottom right corner asking to refresh C++ configurations. Click “Yes” to set up IntelliSense.

Creating a New WPILib Project (Python)

Running the robotpy init command will initialize a new robot project:

Windows

py -3 -m robotpy init

macOS

python3 -m robotpy init

Linux

python3 -m robotpy init

This will create a robot.py and pyproject.toml file, but will not overwrite an existing file.

• The pyproject.toml file contains the requirements for your project, which are downloaded and installed via the robotpy sync command.

• The robot.py file is where you will put the your Robot class.

See also

Download RobotPy for Systemcore

Basic Drivetrain example

First, here is what a simple code can look like for a Drivetrain with PWM controlled motors (such as SparkMax).

Note

the Python example below is from https://github.com/robotpy/mostrobotpy/tree/main/examples/robot/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 org.wpilib.examples.gettingstarted;

import org.wpilib.drive.DifferentialDrive;
import org.wpilib.drivers.motor.PWMSparkMax;
import org.wpilib.driverstation.Gamepad;
import org.wpilib.framework.TimedRobot;
import org.wpilib.system.Timer;

/**
 * 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 leftDrive = new PWMSparkMax(0);
  private final PWMSparkMax rightDrive = new PWMSparkMax(1);
  private final DifferentialDrive robotDrive =
      new DifferentialDrive(leftDrive::setThrottle, rightDrive::setThrottle);
  private final Gamepad controller = new Gamepad(0);
  private final Timer timer = new Timer();

  /** 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.
    rightDrive.setInverted(true);
  }

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

  /** This function is called periodically during autonomous. */
  @Override
  public void autonomousPeriodic() {
    // Drive for 2 seconds
    if (timer.get() < 2.0) {
      // Drive forwards half velocity, make sure to turn input squaring off
      robotDrive.arcadeDrive(0.5, 0.0, false);
    } else {
      robotDrive.arcadeDrive(0.0, 0.0, false); // 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() {
    robotDrive.arcadeDrive(-controller.getLeftY(), -controller.getRightX());
  }

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

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

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 "wpi/drive/DifferentialDrive.hpp"
#include "wpi/drivers/motor/PWMSparkMax.hpp"
#include "wpi/driverstation/Gamepad.hpp"
#include "wpi/framework/TimedRobot.hpp"
#include "wpi/system/Timer.hpp"

class Robot : public wpi::TimedRobot {
 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.
    right.SetInverted(true);
    robotDrive.SetExpiration(100_ms);
    timer.Start();
  }

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

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

  void TeleopInit() override {}

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

  void UtilityInit() override {}

  void UtilityPeriodic() override {}

 private:
  // Robot drive system
  wpi::PWMSparkMax left{0};
  wpi::PWMSparkMax right{1};
  wpi::DifferentialDrive robotDrive{
      [&](double output) { left.SetThrottle(output); },
      [&](double output) { right.SetThrottle(output); }};

  wpi::Gamepad controller{0};
  wpi::Timer timer;
};

#ifndef RUNNING_WPILIB_TESTS
int main() {
  return wpi::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_drivers


class MyRobot(wpilib.TimedRobot):
    def __init__(self):
        """
        This function is called upon program startup and
        should be used for any initialization code.
        """
        super().__init__()
        self.left_drive = wpilib_drivers.PWMSparkMax(0)
        self.right_drive = wpilib_drivers.PWMSparkMax(1)
        self.robot_drive = wpilib.DifferentialDrive(self.left_drive, self.right_drive)
        self.controller = wpilib.Gamepad(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.right_drive.set_inverted(True)

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

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

        # Drive for two seconds
        if self.timer.get() < 2.0:
            # Drive forwards half velocity, make sure to turn input squaring off
            self.robot_drive.arcade_drive(0.5, 0, square_inputs=False)
        else:
            self.robot_drive.arcade_drive(0, 0)  # Stop robot

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

    def teleop_periodic(self):
        """This function is called periodically during teleoperated mode."""
        self.robot_drive.arcade_drive(
            -self.controller.get_left_y(), -self.controller.get_right_x()
        )

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

    def utility_periodic(self):
        """This function is called periodically during utility mode."""

Now let’s look at various parts of the code.

Imports/Includes

PWM

Java

import org.wpilib.drive.DifferentialDrive;
import org.wpilib.drivers.motor.PWMSparkMax;
import org.wpilib.driverstation.Gamepad;
import org.wpilib.framework.TimedRobot;
import org.wpilib.system.Timer;

C++

#include "wpi/drive/DifferentialDrive.hpp"
#include "wpi/drivers/motor/PWMSparkMax.hpp"
#include "wpi/driverstation/Gamepad.hpp"
#include "wpi/framework/TimedRobot.hpp"
#include "wpi/system/Timer.hpp"

Python

import wpilib

CTRE-Phoenix6

JAVA

import org.wpilib.framework.TimedRobot;
import org.wpilib.system.Timer;
import org.wpilib.driverstation.Gamepad;
import org.wpilib.drive.DifferentialDrive;
import com.ctre.phoenix6.hardware.TalonFX;

C++

#include "wpi/framework/TimedRobot.hpp"
#include "wpi/system/Timer.hpp"
#include "wpi/driverstation/Gamepad.hpp"
#include "wpi/drive/DifferentialDrive.hpp"
#include "ctre/phoenix6/TalonFX.hpp"

PYTHON

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

REV

JAVA

import com.revrobotics.CANSparkMax;
import com.revrobotics.CANSparkLowLevel.MotorType;
import org.wpilib.framework.TimedRobot;
import org.wpilib.system.Timer;
import org.wpilib.driverstation.Gamepad;
import org.wpilib.drive.DifferentialDrive;

C++

#include "wpi/framework/TimedRobot.hpp"
#include "wpi/system/Timer.hpp"
#include "wpi/driverstation/Gamepad.hpp"
#include "wpi/drive/DifferentialDrive.hpp"
#include "wpi/hardware/motor/PWMSparkMax.hpp"
#include "rev/CANSparkMax.h"

PYTHON

import wpilib           # Used to get the joysticks and DifferentialDrive class
import rev              # REV library

CTRE-Phoenix5

JAVA

import org.wpilib.framework.TimedRobot;
import org.wpilib.system.Timer;
import org.wpilib.driverstation.Gamepad;
import org.wpilib.drive.DifferentialDrive;
import com.ctre.phoenix.motorcontrol.can.WPI_TalonSRX;

C++

#include "wpi/framework/TimedRobot.hpp"
#include "wpi/system/Timer.hpp"
#include "wpi/driverstation/Gamepad.hpp"
#include "wpi/drive/DifferentialDrive.hpp"
#include "ctre/phoenix/motorcontrol/can/WPI_TalonSRX.h"

PYTHON

import wpilib                            # Used to get the joysticks
from wpilib import DifferentialDrive     # Used for the DifferentialDrive class
import phoenix5                          # Phoenix5 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 Gamepad (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 Gamepad to the motors).

Note

The Gamepad class is used with the 2027 FIRST Driver station. If you are using the NI Driver station, you will need to use the NiDsXboxController class instead.

Defining the variables for our sample robot

PWM

Java

public class Robot extends TimedRobot {
  private final PWMSparkMax leftDrive = new PWMSparkMax(0);
  private final PWMSparkMax rightDrive = new PWMSparkMax(1);
  private final DifferentialDrive robotDrive =
      new DifferentialDrive(leftDrive::setThrottle, rightDrive::setThrottle);
  private final Gamepad controller = new Gamepad(0);
  private final Timer timer = new Timer();

C++

private:
 // Robot drive system
 wpi::PWMSparkMax left{0};
 wpi::PWMSparkMax right{1};
 wpi::DifferentialDrive robotDrive{
     [&](double output) { left.SetThrottle(output); },
     [&](double output) { right.SetThrottle(output); }};

 wpi::Gamepad controller{0};
 wpi::Timer timer;

Python

class MyRobot(wpilib.TimedRobot):
    def __init__(self):
        """
        This function is called upon program startup and
        should be used for any initialization code.
        """
        super().__init__()
        self.left_drive = wpilib_drivers.PWMSparkMax(0)
        self.right_drive = wpilib_drivers.PWMSparkMax(1)
        self.robot_drive = wpilib.DifferentialDrive(self.left_drive, self.right_drive)
        self.controller = wpilib.Gamepad(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.right_drive.set_inverted(True)

CTRE-Phoenix6

Java

public class Robot extends TimedRobot {
   private final TalonFX leftDrive = new TalonFX(1);
   private final TalonFX rightDrive = new TalonFX(2);
   private final DifferentialDrive robotDrive =
     new DifferentialDrive(leftDrive::set, rightDrive::set);
   private final Gamepad controller = new Gamepad(0);
   private final Timer timer = new Timer();

C++

private:
 // Robot drive system
 ctre::phoenix6::hardware::TalonFX left{1};
 ctre::phoenix6::hardware::TalonFX right{2};
 wpi::DifferentialDrive robotDrive{
   [&](double output) { left.Set(output); },
   [&](double output) { right.Set(output); }};
 wpi::Gamepad controller{0};
 wpi::Timer timer;

Python

class MyRobot(wpilib.TimedRobot):
  def __init__(self):
     """
     This function is called upon program startup and
     should be used for any initialization code.
     """
     super().__init__()
     self.left_drive = phoenix6.hardware.TalonFX(1)
     self.right_drive = phoenix6.hardware.TalonFX(2)
     self.robot_drive = DifferentialDrive(
         self.left_drive, self.right_drive
     )
     self.controller = wpilib.Gamepad(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.right_drive.set_inverted(True)

REV

Java

public class Robot extends TimedRobot {
  private final CANSparkMax leftDrive = new CANSparkMax(1, MotorType.kBrushless);
  private final CANSparkMax rightDrive = new CANSparkMax(2, MotorType.kBrushless);
  private final DifferentialDrive robotDrive =
    new DifferentialDrive(leftDrive::set, rightDrive::set);
  private final Gamepad controller = new Gamepad(0);
  private final Timer timer = new Timer();

C++

private:
 // Robot drive system
 rev::CANSparkMax left{1, rev::CANSparkMax::MotorType::kBrushless};
 rev::CANSparkMax right{2, rev::CANSparkMax::MotorType::kBrushless};
 wpi::DifferentialDrive robotDrive{
   [&](double output) { left.Set(output); },
   [&](double output) { right.Set(output); }};
 wpi::Gamepad controller{0};
 wpi::Timer timer;

Python

class MyRobot(wpilib.TimedRobot):
    def __init__(self):
        super().__init__()
        """
        This function is called upon program startup and
        should be used for any initialization code.
        """
        self.leftDrive = rev.SparkMax(0, 1, rev.SparkMax.MotorType.kBrushless)
        self.rightDrive = rev.SparkMax(0, 2, rev.SparkMax.MotorType.kBrushless)
        self.robotDrive = wpilib.DifferentialDrive(self.leftDrive, self.rightDrive)
        self.controller = wpilib.Gamepad(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 leftDrive = new WPI_TalonSRX(1);
   private final WPI_TalonSRX rightDrive = new WPI_TalonSRX(2);
   private final DifferentialDrive robotDrive = new DifferentialDrive(leftDrive1::set, rightDrive2::set);
   private final Gamepad controller = new Gamepad(0);
   private final Timer timer = new Timer();

C++

private:
 // Robot drive system
 ctre::phoenix::motorcontrol::can::WPI_TalonSRX left{1};
 ctre::phoenix::motorcontrol::can::WPI_TalonSRX right{2};
 wpi::DifferentialDrive robotDrive{
   [&](double output) { left.Set(output); },
   [&](double output) { right.Set(output); }};
 wpi::Gamepad controller{0};
 wpi::Timer 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 = phoenix5.WPI_TalonFX(1)
        self.rightDrive = phoenix5.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 (or other Gamepad) 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 (robotDrive), Gamepad (controller) and Timer (timer). This section of the code does three things:

1. Defines the variables as members of our Robot class.

2. Initializes the variables.

Note

The variable initializations for C++ are in the private section at the bottom of the program. This means they are private to the class (Robot).

Robot Initialization

Java

  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.
    rightDrive.setInverted(true);
  }

C++

  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.
    right.SetInverted(true);
    robotDrive.SetExpiration(100_ms);
    timer.Start();
  }

Python

    def __init__(self):
        """
        This function is called upon program startup and
        should be used for any initialization code.
        """
        super().__init__()
        # 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.right_drive.set_inverted(True)

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.

Simple Autonomous Example

JAVA

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

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

C++

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

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

PYTHON

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

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

        # Drive for two seconds
        if self.timer.get() < 2.0:
            # Drive forwards half velocity, make sure to turn input squaring off
            self.robot_drive.arcade_drive(0.5, 0, square_inputs=False)
        else:
            self.robot_drive.arcade_drive(0, 0)  # Stop robot

The AutonomousInit method is run once each time the robot transitions to autonomous from another mode. In this program, we restart the Timer in this method.

AutonomousPeriodic is run once every period while the robot is in autonomous mode. In the TimedRobot class the period is a fixed time, which defaults to 20ms. In this example, the periodic code checks if the timer is less than 2 seconds and if so, drives forward at half speed using the ArcadeDrive method of the DifferentialDrive class. If more than 2 seconds has elapsed, the code stops the robot drive.

Joystick Control for Teleoperation

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() {
    robotDrive.arcadeDrive(-controller.getLeftY(), -controller.getRightX());
  }

C++

  void TeleopInit() override {}

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

PYTHON

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

    def teleop_periodic(self):
        """This function is called periodically during teleoperated mode."""
        self.robot_drive.arcade_drive(
            -self.controller.get_left_y(), -self.controller.get_right_x()
        )

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 Gamepad to forward/back motion of the drive motors and the X-axis to turning motion.

Utility Mode

JAVA

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

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

C++

  void UtilityInit() override {}

  void UtilityPeriodic() override {}

PYTHON

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

    def utility_periodic(self):
        """This function is called periodically during utility mode."""

Utility Mode is used for testing robot functionality or running other code that shouldn’t be run in a match. Similar to TeleopInit, the UtilityInit and UtilityPeriodic methods are provided here for illustrative purposes only.

Deploying the Project to a Robot

Java/C++

In Visual Studio Code, click the WPILib logo in the top right to launch the WPILib Command Palette. Select Deploy Robot Code to deploy the code to the robot.

Note

The run button in VS Code’s debug view is not used to run robot code. Instead, use the Deploy Robot Code command as described above. The debug view’s run button is used for running and debugging code on the local machine in simulation, which is not applicable for robot code that runs on Systemcore.

For more detailed instructions, see Deploy Java/C++ code.

Python

In the terminal, run the following command to deploy the code to the robot:

Windows

py -3 -m robotpy deploy

macOS

python3 -m robotpy deploy

Linux

python3 -m robotpy deploy

For more detailed instructions, see Deploy Python code.