# Shooter/FlyWheels
{% hint style="danger" %}
Mechanism classes are meant to be used with "tightly coupled" mechanisms where the Mechanism has 1 or more motor controlling it on a connected shaft, gearbox, or other linkage.
**IF** your mechanism is "loosely coupled", you **CAN** still use YAMS. **HOWEVER** you have to create and control the `SmartMotorController` directly as shown in [how-do-i-control-a-mechanism-without-a-mechanism-class](https://yagsl.gitbook.io/yams/documentation/how-to/how-do-i-control-a-mechanism-without-a-mechanism-class "mention") OR use `SmartMotorControllerConfig.withLooselyCoupledFollowers(SmartMotorController...)`
{% endhint %}
## Intro
At the end of this tutorial you will have an `Shooter` that will work in both real life and simulation with the same code!
## Details
This `Shooter` will be using the following hardware specs and control details
* `SparkMax` controlling the `Shooter`
* `12:1` GearBox on the `Shooter`
* Pressing `A` will make the `Shooter` go to 60 RPM
* Pressing `B` will make the `Shooter` go to 300 RPM
* Pressing `X` will make the `Shooter` speed up.
* Pressing `Y` will make the `Shooter` slow down.
## Lets create a WPILib Command-Based Project!
{% hint style="success" %}
IF you already have a project and know how to place the `Shooter` mechanism into your own subsystem please skip to [#install-yams](#install-yams "mention")
{% endhint %}
### Setup our Command-Based Project
Here we will follow [WPILib's tutorial ](https://docs.wpilib.org/en/stable/docs/zero-to-robot/step-4/creating-test-drivetrain-program-cpp-java-python.html)on how to create a Command-Based project.
Bring up the Visual Studio Code command palette with Ctrl+Shift+P. Then, type “WPILib” into the prompt. Since all WPILib commands start with “WPILib”, this will bring up the list of WPILib-specific VS Code commands. Now, select the “Create a new project” command:
This will bring up the “New Project Creator Window:”
1. Click on **Select a project type (Example or Template)**
2. Select **Template** then **Java** then **Command Robot**
3. Click on **Select a new project folder** and select a folder to store your robot project in.
4. Fill in **Project Name** with the name of your robot code project.
5. Enter your **Team Number** in so you can deploy to your robot.
6. Be sure to check **Enable Desktop Support** so we can run simulations!
If you followed these instructions it should look something like whats filled out below.
Congratulations! You now have a Command Based robot project!
### Install YAMS!
Click on the **WPILib logo** on the **left** pane. Scroll down to **Yet Another Mechanism System** and click **Install**!
Congratulations you have now installed YAMS! :tada:
## Lets make a Shooter move!
{% stepper %}
{% step %}
### Create a `SmartMotorControllerConfig`
We are going to start by configuring out motor controller.
// 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 static edu.wpi.first.units.Units.Amps;
import static edu.wpi.first.units.Units.DegreesPerSecond;
import static edu.wpi.first.units.Units.DegreesPerSecondPerSecond;
import static edu.wpi.first.units.Units.Seconds;
import edu.wpi.first.math.controller.SimpleMotorFeedforward;
import edu.wpi.first.wpilibj2.command.Command;
import edu.wpi.first.wpilibj2.command.SubsystemBase;
import yams.mechanisms.SmartMechanism;
import yams.motorcontrollers.SmartMotorControllerConfig;
import yams.motorcontrollers.SmartMotorControllerConfig.ControlMode;
import yams.motorcontrollers.SmartMotorControllerConfig.MotorMode;
import yams.motorcontrollers.SmartMotorControllerConfig.TelemetryVerbosity;
public class ExampleSubsystem extends SubsystemBase {
private SmartMotorControllerConfig smcConfig = new SmartMotorControllerConfig(this)
.withControlMode(ControlMode.CLOSED_LOOP)
// Feedback Constants (PID Constants)
.withClosedLoopController(50, 0, 0, DegreesPerSecond.of(90), DegreesPerSecondPerSecond.of(45))
.withSimClosedLoopController(50, 0, 0, DegreesPerSecond.of(90), DegreesPerSecondPerSecond.of(45))
// Feedforward Constants
.withFeedforward(new SimpleMotorFeedforward(0, 0, 0))
.withSimFeedforward(new SimpleMotorFeedforward(0, 0, 0))
// Telemetry name and verbosity level
.withTelemetry("ShooterMotor", TelemetryVerbosity.HIGH)
// Gearing from the motor rotor to final shaft.
// In this example GearBox.fromReductionStages(3,4) is the same as GearBox.fromStages("3:1","4:1") which corresponds to the gearbox attached to your motor.
// You could also use .withGearing(12) which does the same thing.
.withGearing(new MechanismGearing(GearBox.fromReductionStages(3, 4)))
// Motor properties to prevent over currenting.
.withMotorInverted(false)
.withIdleMode(MotorMode.COAST)
.withStatorCurrentLimit(Amps.of(40));
/** Creates a new ExampleSubsystem. */
public ExampleSubsystem() {}
/**
* 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
}
@Override
public void simulationPeriodic() {
// This method will be called once per scheduler run during simulation
}
}
{% endstep %}
{% step %}
### Create our motor controller
To control our `FlyWheel` motor we will create the vendor motor controller object.
First we install `REVLib` by clicking on the WPILib logo in the left bar.
Now we add it to the `ExampleSubsystem.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 static edu.wpi.first.units.Units.Amps;
import static edu.wpi.first.units.Units.Degrees;
import static edu.wpi.first.units.Units.DegreesPerSecond;
import static edu.wpi.first.units.Units.DegreesPerSecondPerSecond;
import static edu.wpi.first.units.Units.Seconds;
import com.revrobotics.spark.SparkLowLevel.MotorType;
import com.revrobotics.spark.SparkMax;
import edu.wpi.first.math.controller.ArmFeedforward;
import edu.wpi.first.wpilibj2.command.Command;
import edu.wpi.first.wpilibj2.command.SubsystemBase;
import yams.mechanisms.SmartMechanism;
import yams.motorcontrollers.SmartMotorControllerConfig;
import yams.motorcontrollers.SmartMotorControllerConfig.ControlMode;
import yams.motorcontrollers.SmartMotorControllerConfig.MotorMode;
import yams.motorcontrollers.SmartMotorControllerConfig.TelemetryVerbosity;
public class ExampleSubsystem extends SubsystemBase {
private SmartMotorControllerConfig smcConfig = new SmartMotorControllerConfig(this)
.withControlMode(ControlMode.CLOSED_LOOP)
// Feedback Constants (PID Constants)
.withClosedLoopController(50, 0, 0, DegreesPerSecond.of(90), DegreesPerSecondPerSecond.of(45))
.withSimClosedLoopController(50, 0, 0, DegreesPerSecond.of(90), DegreesPerSecondPerSecond.of(45))
// Feedforward Constants
.withFeedforward(new SimpleMotorFeedforward(0, 0, 0))
.withSimFeedforward(new SimpleMotorFeedforward(0, 0, 0))
// Telemetry name and verbosity level
.withTelemetry("ShooterMotor", TelemetryVerbosity.HIGH)
// Gearing from the motor rotor to final shaft.
// In this example GearBox.fromReductionStages(3,4) is the same as GearBox.fromStages("3:1","4:1") which corresponds to the gearbox attached to your motor.
// You could also use .withGearing(12) which does the same thing.
.withGearing(new MechanismGearing(GearBox.fromReductionStages(3, 4)))
// Motor properties to prevent over currenting.
.withMotorInverted(false)
.withIdleMode(MotorMode.COAST)
.withStatorCurrentLimit(Amps.of(40));
// Vendor motor controller object
private SparkMax spark = new SparkMax(4, MotorType.kBrushless);
/** Creates a new ExampleSubsystem. */
public ExampleSubsystem() {}
/**
* 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
}
@Override
public void simulationPeriodic() {
// This method will be called once per scheduler run during simulation
}
}
{% endstep %}
{% step %}
### Create our `SmartMotorController`
Our `SmartMotorController` will easily configure and interface with the vendor motor controller object.
// 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 static edu.wpi.first.units.Units.Amps;
import static edu.wpi.first.units.Units.Degrees;
import static edu.wpi.first.units.Units.DegreesPerSecond;
import static edu.wpi.first.units.Units.DegreesPerSecondPerSecond;
import static edu.wpi.first.units.Units.Seconds;
import com.revrobotics.spark.SparkLowLevel.MotorType;
import com.revrobotics.spark.SparkMax;
import edu.wpi.first.math.controller.ArmFeedforward;
import edu.wpi.first.math.system.plant.DCMotor;
import edu.wpi.first.wpilibj2.command.Command;
import edu.wpi.first.wpilibj2.command.SubsystemBase;
import yams.mechanisms.SmartMechanism;
import yams.motorcontrollers.SmartMotorController;
import yams.motorcontrollers.SmartMotorControllerConfig;
import yams.motorcontrollers.SmartMotorControllerConfig.ControlMode;
import yams.motorcontrollers.SmartMotorControllerConfig.MotorMode;
import yams.motorcontrollers.SmartMotorControllerConfig.TelemetryVerbosity;
import yams.motorcontrollers.local.SparkWrapper;
public class ExampleSubsystem extends SubsystemBase {
private SmartMotorControllerConfig smcConfig = new SmartMotorControllerConfig(this)
.withControlMode(ControlMode.CLOSED_LOOP)
// Feedback Constants (PID Constants)
.withClosedLoopController(1, 0, 0)
.withSimClosedLoopController(1, 0, 0)
// Feedforward Constants
.withFeedforward(new SimpleMotorFeedforward(0, 0, 0))
.withSimFeedforward(new SimpleMotorFeedforward(0, 0, 0))
// Telemetry name and verbosity level
.withTelemetry("ShooterMotor", TelemetryVerbosity.HIGH)
// Gearing from the motor rotor to final shaft.
// In this example GearBox.fromReductionStages(3,4) is the same as GearBox.fromStages("3:1","4:1") which corresponds to the gearbox attached to your motor.
// You could also use .withGearing(12) which does the same thing.
.withGearing(new MechanismGearing(GearBox.fromReductionStages(3, 4)))
// Motor properties to prevent over currenting.
.withMotorInverted(false)
.withIdleMode(MotorMode.COAST)
.withStatorCurrentLimit(Amps.of(40));
// Vendor motor controller object
private SparkMax spark = new SparkMax(4, MotorType.kBrushless);
// Create our SmartMotorController from our Spark and config with the NEO.
private SmartMotorController sparkSmartMotorController = new SparkWrapper(spark, DCMotor.getNEO(1), smcConfig);
/** Creates a new ExampleSubsystem. */
public ExampleSubsystem() {}
/**
* 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
}
@Override
public void simulationPeriodic() {
// This method will be called once per scheduler run during simulation
}
}
{% endstep %}
{% step %}
### Create and Configure our `FlyWheel`
Our `FlyWheel` will easily configure the `SmartMotorController` and create a simple and intuitive interface.
// 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 static edu.wpi.first.units.Units.Amps;
import static edu.wpi.first.units.Units.Degrees;
import static edu.wpi.first.units.Units.DegreesPerSecond;
import static edu.wpi.first.units.Units.DegreesPerSecondPerSecond;
import static edu.wpi.first.units.Units.Feet;
import static edu.wpi.first.units.Units.Pounds;
import static edu.wpi.first.units.Units.Seconds;
import com.revrobotics.spark.SparkLowLevel.MotorType;
import com.revrobotics.spark.SparkMax;
import edu.wpi.first.math.controller.ArmFeedforward;
import edu.wpi.first.math.system.plant.DCMotor;
import edu.wpi.first.wpilibj2.command.Command;
import edu.wpi.first.wpilibj2.command.SubsystemBase;
import yams.mechanisms.SmartMechanism;
import yams.mechanisms.config.FlyWheelConfig;
import yams.mechanisms.velocity.FlyWheel;
import yams.motorcontrollers.SmartMotorController;
import yams.motorcontrollers.SmartMotorControllerConfig;
import yams.motorcontrollers.SmartMotorControllerConfig.ControlMode;
import yams.motorcontrollers.SmartMotorControllerConfig.MotorMode;
import yams.motorcontrollers.SmartMotorControllerConfig.TelemetryVerbosity;
import yams.motorcontrollers.local.SparkWrapper;
public class ExampleSubsystem extends SubsystemBase {
private SmartMotorControllerConfig smcConfig = new SmartMotorControllerConfig(this)
.withControlMode(ControlMode.CLOSED_LOOP)
// Feedback Constants (PID Constants)
.withClosedLoopController(1, 0, 0)
.withSimClosedLoopController(1, 0, 0)
// Feedforward Constants
.withFeedforward(new SimpleMotorFeedforward(0, 0, 0))
.withSimFeedforward(new SimpleMotorFeedforward(0, 0, 0))
// Telemetry name and verbosity level
.withTelemetry("ShooterMotor", TelemetryVerbosity.HIGH)
// Gearing from the motor rotor to final shaft.
// In this example GearBox.fromReductionStages(3,4) is the same as GearBox.fromStages("3:1","4:1") which corresponds to the gearbox attached to your motor.
// You could also use .withGearing(12) which does the same thing.
.withGearing(new MechanismGearing(GearBox.fromReductionStages(3, 4)))
// Motor properties to prevent over currenting.
.withMotorInverted(false)
.withIdleMode(MotorMode.COAST)
.withStatorCurrentLimit(Amps.of(40));
// Vendor motor controller object
private SparkMax spark = new SparkMax(4, MotorType.kBrushless);
// Create our SmartMotorController from our Spark and config with the NEO.
private SmartMotorController sparkSmartMotorController = new SparkWrapper(spark, DCMotor.getNEO(1), smcConfig);
private final FlyWheelConfig shooterConfig = new FlyWheelConfig(motor)
// Diameter of the flywheel.
.withDiameter(Inches.of(4))
// Mass of the flywheel.
.withMass(Pounds.of(1))
// Maximum speed of the shooter.
.withUpperSoftLimit(RPM.of(1000))
// Telemetry name and verbosity for the arm.
.withTelemetry("ShooterMech", TelemetryVerbosity.HIGH);
// Shooter Mechanism
private FlyWheel shooter = new FlyWheel(shooterConfig);
/** Creates a new ExampleSubsystem. */
public ExampleSubsystem() {}
/**
* 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
shooter.updateTelemetry();
}
@Override
public void simulationPeriodic() {
// This method will be called once per scheduler run during simulation
shooter.simIterate();
}
}
{% endstep %}
{% step %}
### Create `Command`s with our `FlyWheel`
We use the `FlyWheel` class as a interface to create commands!
// 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 static edu.wpi.first.units.Units.Amps;
import static edu.wpi.first.units.Units.Degrees;
import static edu.wpi.first.units.Units.DegreesPerSecond;
import static edu.wpi.first.units.Units.DegreesPerSecondPerSecond;
import static edu.wpi.first.units.Units.Feet;
import static edu.wpi.first.units.Units.Pounds;
import static edu.wpi.first.units.Units.Second;
import static edu.wpi.first.units.Units.Seconds;
import static edu.wpi.first.units.Units.Volts;
import com.revrobotics.spark.SparkLowLevel.MotorType;
import com.revrobotics.spark.SparkMax;
import edu.wpi.first.math.controller.ArmFeedforward;
import edu.wpi.first.math.system.plant.DCMotor;
import edu.wpi.first.units.measure.AngularVelocity;
import edu.wpi.first.wpilibj2.command.Command;
import edu.wpi.first.wpilibj2.command.SubsystemBase;
import yams.mechanisms.SmartMechanism;
import yams.mechanisms.config.FlyWheelConfig;
import yams.mechanisms.velocity.FlyWheel;
import yams.motorcontrollers.SmartMotorController;
import yams.motorcontrollers.SmartMotorControllerConfig;
import yams.motorcontrollers.SmartMotorControllerConfig.ControlMode;
import yams.motorcontrollers.SmartMotorControllerConfig.MotorMode;
import yams.motorcontrollers.SmartMotorControllerConfig.TelemetryVerbosity;
import yams.motorcontrollers.local.SparkWrapper;
public class ExampleSubsystem extends SubsystemBase {
private SmartMotorControllerConfig smcConfig = new SmartMotorControllerConfig(this)
.withControlMode(ControlMode.CLOSED_LOOP)
// Feedback Constants (PID Constants)
.withClosedLoopController(1, 0, 0)
.withSimClosedLoopController(1, 0, 0)
// Feedforward Constants
.withFeedforward(new SimpleMotorFeedforward(0, 0, 0))
.withSimFeedforward(new SimpleMotorFeedforward(0, 0, 0))
// Telemetry name and verbosity level
.withTelemetry("ShooterMotor", TelemetryVerbosity.HIGH)
// Gearing from the motor rotor to final shaft.
// In this example GearBox.fromReductionStages(3,4) is the same as GearBox.fromStages("3:1","4:1") which corresponds to the gearbox attached to your motor.
// You could also use .withGearing(12) which does the same thing.
.withGearing(new MechanismGearing(GearBox.fromReductionStages(3, 4)))
// Motor properties to prevent over currenting.
.withMotorInverted(false)
.withIdleMode(MotorMode.COAST)
.withStatorCurrentLimit(Amps.of(40));
// Vendor motor controller object
private SparkMax spark = new SparkMax(4, MotorType.kBrushless);
// Create our SmartMotorController from our Spark and config with the NEO.
private SmartMotorController sparkSmartMotorController = new SparkWrapper(spark, DCMotor.getNEO(1), smcConfig);
private final FlyWheelConfig shooterConfig = new FlyWheelConfig(motor)
// Diameter of the flywheel.
.withDiameter(Inches.of(4))
// Mass of the flywheel.
.withMass(Pounds.of(1))
// Maximum speed of the shooter.
.withUpperSoftLimit(RPM.of(1000))
// Telemetry name and verbosity for the arm.
.withTelemetry("ShooterMech", TelemetryVerbosity.HIGH);
// Shooter Mechanism
private FlyWheel shooter = new FlyWheel(shooterConfig);
/**
* Gets the current velocity of the shooter.
*
* @return Shooter velocity.
*/
public AngularVelocity getVelocity() {return shooter.getSpeed();}
/**
* Set the shooter velocity.
*
* @param speed Speed to set.
* @return {@link edu.wpi.first.wpilibj2.command.RunCommand}
*/
public Command setVelocity(AngularVelocity speed) {return shooter.run(speed);}
/**
* Set the shooter velocity setpoint.
*
* @param speed Speed to set
*/
public void setVelocitySetpoint(AngularVelocity speed) {shooter.setMechanismVelocitySetpoint(speed);}
/**
* Set the shooter velocity.
*
* @param speed Speed to set.
* @return {@link edu.wpi.first.wpilibj2.command.RunCommand}
*/
public Command setVelocity(AngularVelocity speed) {return shooter.run(speed);}
/**
* Set the dutycycle of the shooter.
*
* @param dutyCycle DutyCycle to set.
* @return {@link edu.wpi.first.wpilibj2.command.RunCommand}
*/
public Command set(double dutyCycle) {return shooter.set(dutyCycle);}
/** Creates a new ExampleSubsystem. */
public ExampleSubsystem() {}
/**
* 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
shooter.updateTelemetry();
}
@Override
public void simulationPeriodic() {
// This method will be called once per scheduler run during simulation
shooter.simIterate();
}
}
{% endstep %}
{% step %}
### Bind buttons to our `FlyWheel`
We bind buttons to use the `Commands` from our `FlyWheel`
// 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.ExampleSubsystem;
import static edu.wpi.first.units.Units.RPM;
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 ExampleSubsystem m_exampleSubsystem = new ExampleSubsystem();
// 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();
// Set the default command to force the shooter rest.
m_exampleSubsystem.setDefaultCommand(m_exampleSubsystem.set(0));
}
/**
* 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() {
// Schedule `setVelocity` when the Xbox controller's B button is pressed,
// cancelling on release.
m_driverController.a().whileTrue(m_exampleSubsystem.setVelocity(RPM.of(60)));
m_driverController.b().whileTrue(m_exampleSubsystem.setVelocity(RPM.of(300)));
// Schedule `set` when the Xbox controller's B button is pressed,
// cancelling on release.
m_driverController.x().whileTrue(m_exampleSubsystem.set(0.3));
m_driverController.y().whileTrue(m_exampleSubsystem.set(-0.3));
}
/**
* 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(m_exampleSubsystem);
}
}
{% endstep %}
{% step %}
### Simulate our FlyWheel!
We can use our `FlyWheel` in simulation, with the exact same code that will control the real robot!
Connect an Xbox controller to your system and drag and drop from **System Joysticks** to **Joystick\[0]**
Open up the Simulated mechanism with **NetworkTables -> SmartDashboard -> Shooter-> mechanism**
Resize **ShooterMech/mechanism** to your liking
Press **Teleoperated** in **Robot State** then you can use your controller like its controlling the real robot!
Congratulations on successfully programming your Shooter!! :tada::tada:
{% endstep %}
{% endstepper %}
{% hint style="info" %}
Examples can be found in the YAMS repository on GitHub.
{% endhint %}
