Tank Drive Example

Here is a base code that will move the robot.

TankDriveSubsystem

Moves the robot's motors.

TankDriveSubsystem.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 frc.robot.subsystems;

import com.revrobotics.servohub.ServoHub.ResetMode;
import com.revrobotics.spark.SparkMax;
import com.revrobotics.spark.SparkBase.PersistMode;
import com.revrobotics.spark.SparkLowLevel.MotorType;
import com.revrobotics.spark.config.SparkBaseConfig;
import com.revrobotics.spark.config.SparkMaxConfig;
import com.revrobotics.spark.SparkBase.*;

import edu.wpi.first.math.MathUsageId;
import edu.wpi.first.math.MathUtil;
import edu.wpi.first.wpilibj2.command.Command;
import edu.wpi.first.wpilibj2.command.SubsystemBase;

public class TankDriveSubsystem extends SubsystemBase {

private static SparkBaseConfig config = new SparkMaxConfig();

/* sparkmax motors */
private static SparkMax LMotor1 = new SparkMax(1, MotorType.kBrushless);
private static SparkMax LMotor2 = new SparkMax(2, MotorType.kBrushless);

private static SparkMax RMotor1 = new SparkMax(3, MotorType.kBrushless);
private static SparkMax RMotor2 = new SparkMax(4, MotorType.kBrushless);

private static final double speedLimit = 0.25;

private static TankDriveSubsystem tankDriveSubsystem = new TankDriveSubsystem();
/* robot graph
 *    front
 *  O---------O
 *  |         |
 *  |LM1   RM1|
 *  O         O
 *  |LM2   RM2|
 *  |         |
 *  O---------O
       back
 */    

  /** Creates a new TankDrive subsystem. Primarially for training. */
  public TankDriveSubsystem() {
    config.inverted(false);
    LMotor2.configure(config, com.revrobotics.spark.SparkBase.ResetMode.kResetSafeParameters, PersistMode.kPersistParameters);
    config.inverted(true);
    RMotor1.configure(config, com.revrobotics.spark.SparkBase.ResetMode.kResetSafeParameters, PersistMode.kPersistParameters);
    RMotor2.configure(config, com.revrobotics.spark.SparkBase.ResetMode.kResetSafeParameters, PersistMode.kPersistParameters);
  
  }
  
  /** GetInstance() command, simply returns an instance of the Subsystem */
  public static TankDriveSubsystem getInstance() {
    if (tankDriveSubsystem == null) {
      tankDriveSubsystem = new TankDriveSubsystem();

    }

    return tankDriveSubsystem;
  }

  /**
   * Example command factory method.
   *
   * @return a command
   */
  public Command exampleMethodCommand() {
    // Inline construction of command goes here.
    // Subsystem::RunOnce implicitly requires `this` subsystem.
    return runOnce(
        () -> {
          /* one-time action goes here */
        });
  }

  /**
   * An example method querying a boolean state of the subsystem (for example, a digital sensor).
   *
   * @return value of some boolean subsystem state, such as a digital sensor.
   */
  public boolean exampleCondition() {
    // Query some boolean state, such as a digital sensor.
    return false;
  }

  @Override
  public void periodic() {
    // This method will be called once per scheduler run
  }

  /** Sets the motor's speed. 
   * @param speed The speed of the motors.
   * @param isLeftSide Used to choose which side of the robot you want to move. Name's self explanatory.
   * 
  */

  private void setLeftMotors(double speed) {
    LMotor1.set(speed);
    LMotor2.set(speed);

  }

  private void setRightMotors(double speed) {
    RMotor1.set(speed);
    RMotor2.set(speed);

  }

  public void setMotorSpeed(double leftSpeed, double rightSpeed, boolean isLeftSide) {
    /* sets speed of left/right side motors, depending on which joystick's pushed */
    setLeftMotors(leftSpeed);
    setRightMotors(rightSpeed);    
  }

  @Override
  public void simulationPeriodic() {
    // This method will be called once per scheduler run during simulation
  }
}

---

RobotContainer

RobotContainer.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 frc.robot;

import frc.robot.Constants.OperatorConstants;
import frc.robot.commands.Autos;
import frc.robot.commands.ExampleCommand;
import frc.robot.subsystems.TankDriveSubsystem;
import edu.wpi.first.wpilibj2.command.Command;
import edu.wpi.first.wpilibj2.command.button.CommandXboxController;
import edu.wpi.first.wpilibj2.command.button.Trigger;

/**
 * This class is where the bulk of the robot should be declared. Since Command-based is a
 * "declarative" paradigm, very little robot logic should actually be handled in the {@link Robot}
 * periodic methods (other than the scheduler calls). Instead, the structure of the robot (including
 * subsystems, commands, and trigger mappings) should be declared here.
 */
public class RobotContainer {
  // The robot's subsystems and commands are defined here...
  private final TankDriveSubsystem tankDriveSubsystem = new TankDriveSubsystem();

  // Replace with CommandPS4Controller or CommandJoystick if needed
  private final CommandXboxController m_driverController =
      new CommandXboxController(OperatorConstants.kDriverControllerPort);

  /** The container for the robot. Contains subsystems, OI devices, and commands. */
  public RobotContainer() {
    // Configure the trigger bindings
    configureBindings();
  }

  /**
   * Use this method to define your trigger->command mappings. Triggers can be created via the
   * {@link Trigger#Trigger(java.util.function.BooleanSupplier)} constructor with an arbitrary
   * predicate, or via the named factories in {@link
   * edu.wpi.first.wpilibj2.command.button.CommandGenericHID}'s subclasses for {@link
   * CommandXboxController Xbox}/{@link edu.wpi.first.wpilibj2.command.button.CommandPS4Controller
   * PS4} controllers or {@link edu.wpi.first.wpilibj2.command.button.CommandJoystick Flight
   * joysticks}.
   */
  private void configureBindings() {
    /*
     * sends commands depending on which joystick's used atm
     * (ex: if left joystick is moved forward, move left side of robot forward)
    */
 
   /* Move the robot depending on which joysticks are being used. */
    m_driverController.leftStick()
    .whileTrue(new MoveRobotCommand(tankDriveSubsystem, m_driverController.getLeftY() * 10, true));

   m_driverController.leftStick()
   .onFalse(new MoveRobotCommand(tankDriveSubsystem, 0, true));

    m_driverController.rightStick()
    .whileTrue(new MoveRobotCommand(tankDriveSubsystem, m_driverController.getRightY() * 10, false));

    m_driverController.rightStick()
    .onFalse(new MoveRobotCommand(tankDriveSubsystem, 0, false));

  }

  /**
   * Use this to pass the autonomous command to the main {@link Robot} class.
   * @return the command to run in autonomous
   */
  public Command getAutonomousCommand() {
    // An example command will be run in autonomous
    return Autos.exampleAuto(tankDriveSubsystem);
  }
}

MoveMotorCommand

// 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 frc.robot.commands;

import frc.robot.subsystems.*;
import edu.wpi.first.wpilibj2.command.Command;

/** An example command that uses an example subsystem. */
public class MoveRobotCommand extends Command {
  @SuppressWarnings({"PMD.UnusedPrivateField", "PMD.SingularField"})
  private final TankDriveSubsystem m_subsystem;

  private boolean isLeftSide = false;
  private double speed = 0.0;

  /**
   * Creates a new ExampleCommand.
   *
   * @param subsystem The subsystem used by this command.
   */
  public MoveRobotCommand(TankDriveSubsystem subsystem, double newSpeed, boolean lSide) {
    m_subsystem = subsystem;
    speed = newSpeed;
    isLeftSide = lSide;
    
    // Use addRequirements() here to declare subsystem dependencies.
    addRequirements(subsystem);
  }

  // Called when the command is initially scheduled.
  @Override
  public void initialize() {

  }

  // Called every time the scheduler runs while the command is scheduled.
  @Override
  public void execute() {
    //m_subsystem.setMotorSpeed(speed, isLeftSide);

  }

  // Called once the command ends or is interrupted.
  @Override
  public void end(boolean interrupted) {}

  // Returns true when the command should end.
  @Override
  public boolean isFinished() {
    return false;
  }
}

The Tank Drive Subsystem file should go into the robot/subsystems folder and the robotcontainer file should be in the robot folder.

When the program is connected and enabled, it moves the left pair of wheels at a speed that is the magnitude of the left xbox controller stick's height value. The right pair of wheels is moved the same way except the magnitude is determined by the right xbox controller stick's height value.