Creating a Basic Driving Robot#

1) Create 4 global variables of data type SparkMax and name them: leftLeader, rightLeader, leftFollower, rightFollower

• To get started type the word SparkMax followed by the name i.e. private Final SparkMax leftLeader;
• These will eventually hold the object values for SparkMaxes, their port numbers, and their motor type (brushed or brushless).

2) These are declared without values right now.

• We do this to make sure it is empty at this point.
• When we assign these variables a value, we will be getting the motor controller's port numbers out of Constants
  • This means we cannot assign them at the global level

Now that we have created the SparkMaxes and the Drive Constants we must initialize them and tell them what port on the roboRIO they are on.

1) Initialize (set value of) leftLeader to new SparkMax(LEFT_LEADER_ID, MotorType.KBrushed). - This initializes a new SparkMax, leftLeader, in a new piece of memory and states it is on the port defined by LEFT_LEADER_ID. - This should be done within the constructor Drivetrain() - This calls the constructor Talon(int) in the Talon class. - The constructor Talon(int) takes a variable of type int. In this case the int (integer) refers to the port number on the roboRIO.

??? Info "roboRIO port diagram"
      ![](../assets/images/driving_robot/roboRIO_port.png)

1) Before we initalize the SparkMax objects we are going to create constants to hold the CAN ID's of the motors. This will happen in constants.java - Inside the constants class, create a new class called public static DriveConstants. - Inside DriveConstants class, create for constants called LEFT_LEADER_ID, LEFT_FOLLOWER_ID, RIGHT_LEADER_ID, and RIGHT_FOLLOWER_ID. - Back in your DriveTrain class in drivetrain.java, import the DriveConstants class as follows: Import frc.robot.Constants.DriveConstants;.

1) To use Constants, instead of putting 0 for the port in the SparkMax type:

DriveConstants.LEFT_LEADER_ID

2) Replace the remaining numbers with constants.

1) Create the DifferentialDrive object.

Outside of the constructor type:

 private final DifferentialDrive drive;

drive = new DifferentialDrive(leftMotors, rightMotors);

• Since DifferentialDrive only takes 2 parameters we need to create speed controller groups to combine like motor controllers together.
  • In this case we will combine the left motors together and the right motors together.

2) In order to configure the motors to drive correctly, we need to configure one on each side as the leader and one as the follower. In the constructor we are goint to set the followe motors and link them to the leader motors. To do this we will need to include a couple more classes from the REV Library:

import com.revrobotics.spark.SparkBase.PersistMode;
import com.revrobotics.spark.SparkBase.ResetMode;

config.follow(leftLeader);
leftFollower.configure(config, ResetMode.kResetSafeParameters, PersistMode.kPersistParameters);
config.follow(rightLeader);
rightFollower.configure(config, ResetMode.kResetSafeParameters, PersistMode.kPersistParameters);

Remove following, then apply config to right leader

config.disableFollowerMode();
rightLeader.configure(config, ResetMode.kResetSafeParameters, PersistMode.kPersistParameters);

config.inverted(true);
leftLeader.configure(config, ResetMode.kResetSafeParameters, PersistMode.kPersistParameters);

1) Let’s create a public void method called “arcadeDrive” with type “double” parameters moveSpeed and rotateSpeed.

Below the periodic method create a new method called arcadeDrive. This method will be called from our Drive command to actually move the robot.

public void arcadeDrive(double moveSpeed, double rotateSpeed) {

}

2) Now lets make our method call the differentialDrive's arcadeDrive method.

Inside our method type:

drive.arcadeDrive(moveSpeed, rotateSpeed);

DifferentialDrive's arcadeDrive method takes parameters moveValue and rotateValue.

1) Create xspeed and zrotation variables. (to be passed to drive subsystem). These will be declared as DoubleSuppliers, which is a function that return a type. This is important for later. 2) Create an emtpy driveSubsystem instance of DriveSubsystem

import frc.robot.subsystems.DriveSubsystem;
import java.util.function.DoubleSupplier; 

private final DoubleSupplier xSpeed;
private final DoubleSupplier zRotation;
private final DriveSubsystem driveSubsystem;

1) Inside the parenthesis of the the constructor driveArcade() add 3 variables:

  public DriveCommand(
  DoubleSupplier xSpeed, DoubleSupplier zRotation, DriveSubsystem driveSubsystem)

2) Inside constructor DriveArcade() type:

this.xSpeed = xSpeed;
this.zRotation = zRotation;
this.driveSubsystem = driveSubsystem;
addRequirements(this.drivetrain);

• The 3 lines starting with this set the global variables we defined at the top of our class file to the values being passed into the consturctor.

• addRequirements means this command will end all other commands currently using drivetrain and will run instead when executed.
• It also means, other commands that require drivetrain will stop this command and run instead when executed.

1) In the execute method we will we want to call the arcadeDrive method we created in Drivetrain and give it the variables moveSpeed xspeed and rotateSpeed zrotation we created as parameters.

In the execute() method below rotateSpeed type:

driveSubsystem.driveArcade(xSpeed.getAsDouble(), zRotation.getAsDouble());

1) To do this we are going to continue having isFinished return false, meaning the command will never finish.

(We don't need to change anything as this is the default)

1) We will call the arcadeDrive method and give it 0 and 0 as the parameters. this will stop the robot when the command completes.

In the end() method type:

RobotContainer.m_drivetrain.arcadeDrive(0, 0);

• This make the motors stop running when the command ends by setting the movement speed to zero and rotation speed to zero.

1) Open Constants.java Check and make sure the kDriverControllerPort constant is present. 2) Open RobotContainer.java - in the imports section, change ExampleCommand to DriveCommand. - inside the class, find the line private final ExampleSubsystem m_exampleSubsystem = new ExampleSubsystem(); and change ExampleSubsystem to DriveSubsystem and m_exampleSubsystem to drivetrain.

1) Back in RobotContainer.java We will need to remove everything inside the configureBindings method. 2) in the configureBindingswe will call the setDefaultCommand of drivetrain and create a new DriveArcade command with parameters.

• We will the default command for the drive subsystem to an instance of the DriveArcade with the values provided by the joystick axes on the driver controller.
• The Y axis of the controller is inverted so that pushing the stick away from you (a negative value) drives the robot forwards (a positive value).
• Similarly for the X axis where we need to flip the value so the joystick matches the WPILib convention of counter-clockwise positive

driveSubsystem.setDefaultCommand(new DriveArcade(
    () -> -m_driverController.getLeftY()
    () -> -m_driverController.getRightX(),
    driveSubsystem));