Drivetrain Java

En esta guía crearás un drivetrain diferencial moderno utilizando Java y WPILib.

El objetivo es aprender:

Cómo crear un proyecto FRC
Cómo funciona un drivetrain diferencial
Cómo utilizar leaders y followers
Cómo controlar el robot con un control Xbox
Cómo configurar motores brushless
Cómo desplegar código al roboRIO
Cómo probar el robot desde Driver Station

¿Qué es un Differential Drivetrain?

Un Differential Drivetrain utiliza lados izquierdo y derecho independientes para mover el robot.

La mayoría de robots FRC tipo tanque utilizan:

2 motores izquierdos
2 motores derechos
Leaders y followers
Control arcade con control Xbox
Motores brushless conectados por CAN

Antes de comenzar

Asegúrate de tener:

WPILib instalado
VS Code configurado
roboRIO configurado
Driver Station funcionando
Control Xbox conectado
Motores y controladores correctamente cableados

WPILib Setup

Instala y configura correctamente WPILib antes de continuar.

Driver Station

Aprende a utilizar Driver Station y verificar comunicación.

Crear un nuevo proyecto

Abre VS Code y presiona:

CTRL + SHIFT + P

Busca el comando:

Configuración del proyecto

Selecciona las siguientes opciones:

Project Type

Template

Language

Java

Base

Timed Robot

Template

Timed Robot

Información del proyecto

Completa:

Project Name
Team Number
Project Location

Después selecciona:

Generate Project

Abrir el proyecto

Cuando el proyecto termine de generarse:

VS Code abrirá automáticamente la carpeta
WPILib comenzará a cargar dependencias
Espera a que Gradle termine

Estructura del proyecto

La estructura principal se verá similar a esta:

src/
└── main/
    └── java/
        └── frc/
            └── robot/
                ├── Main.java
                ├── Robot.java
                └── Constants.java

Archivo principal del robot

El archivo principal será:

src/main/java/frc/robot/Robot.java

¿Qué vamos a construir?

Crearemos un drivetrain con:

4 motores brushless
Leaders y followers
Differential Drive
Control Xbox
Arcade Drive

La estructura será similar a esta:

Left Side
├── Left Leader
└── Left Follower

Right Side
├── Right Leader
└── Right Follower

CAN IDs

Cada controlador de motor necesita un CAN ID único.

En este ejemplo utilizaremos:

Motor	CAN ID
Left Leader	10
Left Follower	11
Right Leader	12
Right Follower	13

Importando librerías

Primero agregaremos las librerías necesarias.

package frc.robot;

import com.revrobotics.spark.SparkLowLevel.MotorType;
import com.revrobotics.spark.SparkMax;
import com.revrobotics.spark.SparkBase.PersistMode;
import com.revrobotics.spark.SparkBase.ResetMode;
import com.revrobotics.spark.config.SparkMaxConfig;

import edu.wpi.first.wpilibj.TimedRobot;
import edu.wpi.first.wpilibj.XboxController;
import edu.wpi.first.wpilibj.drive.DifferentialDrive;

Declarando motores

Ahora declararemos los motores del drivetrain.

// Left side motors
private final SparkMax leftLeader =
    new SparkMax(10, MotorType.kBrushless);

private final SparkMax leftFollower =
    new SparkMax(11, MotorType.kBrushless);

// Right side motors
private final SparkMax rightLeader =
    new SparkMax(12, MotorType.kBrushless);

private final SparkMax rightFollower =
    new SparkMax(13, MotorType.kBrushless);

¿Qué son Leaders y Followers?

En un drivetrain FRC moderno normalmente existen:

Motores leaders
Motores followers

El motor leader recibe comandos directamente desde el código.

El follower copia automáticamente el comportamiento del leader del mismo lado.

Esto permite:

Simplificar el código
Mantener sincronizados los motores
Reducir errores

Configurando el control Xbox

Ahora agregaremos un control Xbox.

private final XboxController controller =
    new XboxController(0);

Configurando Differential Drive

Ahora crearemos el drivetrain principal.

private final DifferentialDrive drive =
    new DifferentialDrive(leftLeader, rightLeader);

Configurando Followers

Dentro de robotInit() configuraremos followers usando SparkMaxConfig.

@Override
public void robotInit() {

    SparkMaxConfig leftFollowerConfig = new SparkMaxConfig();
    leftFollowerConfig.follow(leftLeader);
    leftFollower.configure(leftFollowerConfig, ResetMode.kResetSafeParameters, PersistMode.kPersistParameters);

    SparkMaxConfig rightFollowerConfig = new SparkMaxConfig();
    rightFollowerConfig.follow(rightLeader);
    rightFollower.configure(rightFollowerConfig, ResetMode.kResetSafeParameters, PersistMode.kPersistParameters);

}

Invirtiendo motores

En la mayoría de drivetrains un lado debe invertirse.

@Override
public void robotInit() {

    SparkMaxConfig leftFollowerConfig = new SparkMaxConfig();
    leftFollowerConfig.follow(leftLeader);
    leftFollower.configure(leftFollowerConfig, ResetMode.kResetSafeParameters, PersistMode.kPersistParameters);

    SparkMaxConfig rightFollowerConfig = new SparkMaxConfig();
    rightFollowerConfig.follow(rightLeader);
    rightFollower.configure(rightFollowerConfig, ResetMode.kResetSafeParameters, PersistMode.kPersistParameters);

    SparkMaxConfig rightLeaderConfig = new SparkMaxConfig();
    rightLeaderConfig.inverted(true);
    rightLeader.configure(rightLeaderConfig, ResetMode.kResetSafeParameters, PersistMode.kPersistParameters);

}

Configurando Arcade Drive

Ahora agregaremos control manual dentro de:

teleopPeriodic()

Lectura de controles

double speed =
    -controller.getLeftY();

double rotation =
    controller.getRightX();

¿Qué hace este código?

-controller.getLeftY();

Lee el stick izquierdo para avanzar y retroceder.

controller.getRightX();

Lee el stick derecho para girar.

Moviendo el robot

drive.arcadeDrive(speed, rotation);

Esto convierte velocidad y rotación en movimiento para el drivetrain.

¿Cómo funciona Arcade Drive?

Con este sistema:

Stick izquierdo → adelante y atrás
Stick derecho → giro o pivote

Si avanzas y giras al mismo tiempo:

el robot girará suavemente mientras avanza

Este es uno de los métodos de control más utilizados en FRC.

Código completo del robot

package frc.robot;

import com.revrobotics.spark.SparkLowLevel.MotorType;
import com.revrobotics.spark.SparkMax;
import com.revrobotics.spark.SparkBase.PersistMode;
import com.revrobotics.spark.SparkBase.ResetMode;
import com.revrobotics.spark.config.SparkMaxConfig;

import edu.wpi.first.wpilibj.TimedRobot;
import edu.wpi.first.wpilibj.XboxController;
import edu.wpi.first.wpilibj.drive.DifferentialDrive;

public class Robot extends TimedRobot {

    // Left side motors
    private final SparkMax leftLeader =
        new SparkMax(10, MotorType.kBrushless);

    private final SparkMax leftFollower =
        new SparkMax(11, MotorType.kBrushless);

    // Right side motors
    private final SparkMax rightLeader =
        new SparkMax(12, MotorType.kBrushless);

    private final SparkMax rightFollower =
        new SparkMax(13, MotorType.kBrushless);

    // Xbox controller
    private final XboxController controller =
        new XboxController(0);

    // Differential drivetrain
    private final DifferentialDrive drive =
        new DifferentialDrive(leftLeader, rightLeader);

    @Override
    public void robotInit() {

        // Configure followers
        SparkMaxConfig leftFollowerConfig = new SparkMaxConfig();
        leftFollowerConfig.follow(leftLeader);
        leftFollower.configure(leftFollowerConfig, ResetMode.kResetSafeParameters, PersistMode.kPersistParameters);

        SparkMaxConfig rightFollowerConfig = new SparkMaxConfig();
        rightFollowerConfig.follow(rightLeader);
        rightFollower.configure(rightFollowerConfig, ResetMode.kResetSafeParameters, PersistMode.kPersistParameters);

        // Invert right side
        SparkMaxConfig rightLeaderConfig = new SparkMaxConfig();
        rightLeaderConfig.inverted(true);
        rightLeader.configure(rightLeaderConfig, ResetMode.kResetSafeParameters, PersistMode.kPersistParameters);
    }

    @Override
    public void teleopPeriodic() {

        // Forward and backward
        double speed =
            -controller.getLeftY();

        // Rotation
        double rotation =
            controller.getRightX();

        // Drive robot
        drive.arcadeDrive(speed, rotation);
    }
}

Métodos importantes

Este método se ejecuta una sola vez cuando el programa del robot inicia. Se utiliza para preparar el robot antes de comenzar a operar, inicializando motores, sensores, controles y cualquier configuración necesaria para el resto del código.

Desplegar código al robot

Conecta el roboRIO por Ethernet o USB.

Después:

Abre el proyecto
Presiona el ícono de WPILib
Selecciona:

WPILib: Deploy Robot Code

Verificar comunicación

Abre Driver Station y verifica:

Communications = verde
Robot Code = verde
Joysticks = verde

Habilitar el robot

Selecciona Teleoperated
Presiona Enable
Mueve el joystick

El robot debería responder inmediatamente.

Problemas comunes

Verifica conexión al roboRIO
Revisa Team Number
Reinicia VS Code
Verifica firewall de Windows

Siguientes pasos

Ahora puedes continuar con:

Corriendo el programa
Driver Station
Command-Based Programming
Sensores
Autonomous
Dashboards

FIRSTHub es un proyecto comunitario independiente. No está afiliado, patrocinado ni respaldado por FIRST. Las traducciones no sustituyen a la documentación oficial: ante cualquier diferencia, manda el documento original.