It is advised to statically import this class (or one of its inner classes) wherever the + * constants are needed, to reduce verbosity. + */ +public final class Constants { + public static class ArmConstants { + public static final int kLowerSparkPort = 20; + public static final int kUpperSparkPort = 21; + public static final int kLowerEncoderChannel = 7; + public static final int kUpperEncoderChannel = 8; + public static final int kLowerLimitChannel = 0; + public static final int kUpperLimitChannel = 1; + + public static final double kLowerOffset = 304.632908 - 180; // opposite - 180 + public static final double kUpperOffset = 279.201265 - 90; // vertical - 90 + public static final double kLowerMaxVolts = 4; + public static final double kUpperMaxVolts = 6; + + public static final double kDefaultLowerP = 0.05; + public static final double kDefaultLowerI = 0.003; + public static final double kDefaultLowerD = 0; + public static final double kDefaultLowerS = 0; + public static final double kDefaultLowerG = 0.2; + public static final double kDefaultLowerV = 0; + public static final double kDefaultLowerA = 0; + + public static final double kDefaultUpperP = 0.06; + public static final double kDefaultUpperI = 0.004; + public static final double kDefaultUpperD = 0; + public static final double kDefaultUpperS = 0; + public static final double kDefaultUpperG = 0.2; + public static final double kDefaultUpperV = 0; + public static final double kDefaultUpperA = 0; + + public static void initArmPreferences() { + Preferences.initDouble("kArmLowerP", ArmConstants.kDefaultLowerP); + Preferences.initDouble("kArmLowerI", ArmConstants.kDefaultLowerI); + Preferences.initDouble("kArmLowerD", ArmConstants.kDefaultLowerD); + Preferences.initDouble("kArmLowerS", ArmConstants.kDefaultLowerS); + Preferences.initDouble("kArmLowerG", ArmConstants.kDefaultLowerG); + Preferences.initDouble("kArmLowerV", ArmConstants.kDefaultLowerV); + Preferences.initDouble("kArmLowerA", ArmConstants.kDefaultLowerA); + + Preferences.initDouble("kArmUpperP", ArmConstants.kDefaultUpperP); + Preferences.initDouble("kArmUpperI", ArmConstants.kDefaultUpperI); + Preferences.initDouble("kArmUpperD", ArmConstants.kDefaultUpperD); + Preferences.initDouble("kArmUpperS", ArmConstants.kDefaultUpperS); + Preferences.initDouble("kArmUpperG", ArmConstants.kDefaultUpperG); + Preferences.initDouble("kArmUpperV", ArmConstants.kDefaultUpperV); + Preferences.initDouble("kArmUpperA", ArmConstants.kDefaultUpperA); + + System.out.println("Arm robot preferences initialized."); + } + + public static void resetArmPreferences() { + Preferences.setDouble("kArmLowerP", ArmConstants.kDefaultLowerP); + Preferences.setDouble("kArmLowerI", ArmConstants.kDefaultLowerI); + Preferences.setDouble("kArmLowerD", ArmConstants.kDefaultLowerD); + Preferences.setDouble("kArmLowerS", ArmConstants.kDefaultLowerS); + Preferences.setDouble("kArmLowerG", ArmConstants.kDefaultLowerG); + Preferences.setDouble("kArmLowerV", ArmConstants.kDefaultLowerV); + Preferences.setDouble("kArmLowerA", ArmConstants.kDefaultLowerA); + + Preferences.setDouble("kArmUpperP", ArmConstants.kDefaultUpperP); + Preferences.setDouble("kArmUpperI", ArmConstants.kDefaultUpperI); + Preferences.setDouble("kArmUpperD", ArmConstants.kDefaultUpperD); + Preferences.setDouble("kArmUpperS", ArmConstants.kDefaultUpperS); + Preferences.setDouble("kArmUpperG", ArmConstants.kDefaultUpperG); + Preferences.setDouble("kArmUpperV", ArmConstants.kDefaultUpperV); + Preferences.setDouble("kArmUpperA", ArmConstants.kDefaultUpperA); + + System.out.println("Arm robot preferences reset."); + } + + public static double getKLowerP() { + return Preferences.getDouble("kArmLowerP", kDefaultLowerP); + } + + public static double getKLowerI() { + return Preferences.getDouble("kArmLowerI", kDefaultLowerI); + } + + public static double getKLowerD() { + return Preferences.getDouble("kArmLowerD", kDefaultLowerD); + } + + public static double getKLowerS() { + return Preferences.getDouble("kArmLowerS", kDefaultLowerS); + } + + public static double getKLowerG() { + return Preferences.getDouble("kArmLowerG", kDefaultLowerG); + } + + public static double getKLowerV() { + return Preferences.getDouble("kArmLowerV", kDefaultLowerV); + } + + public static double getKLowerA() { + return Preferences.getDouble("kArmLowerA", kDefaultLowerA); + } + + public static double getKUpperP() { + return Preferences.getDouble("kArmUpperP", kDefaultUpperP); + } + + public static double getKUpperI() { + return Preferences.getDouble("kArmUpperI", kDefaultUpperI); + } + + public static double getKUpperD() { + return Preferences.getDouble("kArmUpperD", kDefaultUpperD); + } + + public static double getKUpperS() { + return Preferences.getDouble("kArmUpperS", kDefaultUpperS); + } + + public static double getKUpperG() { + return Preferences.getDouble("kArmUpperG", kDefaultUpperG); + } + + public static double getKUpperV() { + return Preferences.getDouble("kArmUpperV", kDefaultUpperV); + } + + public static double getKUpperA() { + return Preferences.getDouble("kArmUpperA", kDefaultUpperA); + } + } + + public static class ClawConstants { + public static final int kSolenoidPort = 6; + } + + public static class OperatorConstants { + public static final int kDriverControllerPort = 0; + public static final int kAuxDriverControllerPort = 1; + } +} diff --git a/src/main/java/frc/robot/Main.java b/src/main/java/frc/robot/Main.java new file mode 100644 index 0000000..8776e5d --- /dev/null +++ b/src/main/java/frc/robot/Main.java @@ -0,0 +1,25 @@ +// 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 edu.wpi.first.wpilibj.RobotBase; + +/** + * Do NOT add any static variables to this class, or any initialization at all. Unless you know what + * you are doing, do not modify this file except to change the parameter class to the startRobot + * call. + */ +public final class Main { + private Main() {} + + /** + * Main initialization function. Do not perform any initialization here. + * + *
If you change your main robot class, change the parameter type. + */ + public static void main(String... args) { + RobotBase.startRobot(Robot::new); + } +} diff --git a/src/main/java/frc/robot/Robot.java b/src/main/java/frc/robot/Robot.java new file mode 100644 index 0000000..687a0a0 --- /dev/null +++ b/src/main/java/frc/robot/Robot.java @@ -0,0 +1,103 @@ +// 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 edu.wpi.first.wpilibj.TimedRobot; +import edu.wpi.first.wpilibj2.command.Command; +import edu.wpi.first.wpilibj2.command.CommandScheduler; + +/** + * The VM is configured to automatically run this class, and to call the functions 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 build.gradle file in the + * project. + */ +public class Robot extends TimedRobot { + private Command m_autonomousCommand; + + private RobotContainer m_robotContainer; + + /** + * This function is run when the robot is first started up and should be used for any + * initialization code. + */ + @Override + public void robotInit() { + // Instantiate our RobotContainer. This will perform all our button bindings, and put our + // autonomous chooser on the dashboard. + m_robotContainer = new RobotContainer(); + } + + /** + * This function is called every 20 ms, no matter the mode. Use this for items like diagnostics + * that you want ran during disabled, autonomous, teleoperated and test. + * + *
This runs after the mode specific periodic functions, but before LiveWindow and + * SmartDashboard integrated updating. + */ + @Override + public void robotPeriodic() { + // Runs the Scheduler. This is responsible for polling buttons, adding newly-scheduled + // commands, running already-scheduled commands, removing finished or interrupted commands, + // and running subsystem periodic() methods. This must be called from the robot's periodic + // block in order for anything in the Command-based framework to work. + CommandScheduler.getInstance().run(); + } + + /** This function is called once each time the robot enters Disabled mode. */ + @Override + public void disabledInit() {} + + @Override + public void disabledPeriodic() {} + + /** This autonomous runs the autonomous command selected by your {@link RobotContainer} class. */ + @Override + public void autonomousInit() { + m_autonomousCommand = m_robotContainer.getAutonomousCommand(); + + // schedule the autonomous command (example) + if (m_autonomousCommand != null) { + m_autonomousCommand.schedule(); + } + } + + /** This function is called periodically during autonomous. */ + @Override + public void autonomousPeriodic() {} + + @Override + public void teleopInit() { + // This makes sure that the autonomous stops running when + // teleop starts running. If you want the autonomous to + // continue until interrupted by another command, remove + // this line or comment it out. + if (m_autonomousCommand != null) { + m_autonomousCommand.cancel(); + } + } + + /** This function is called periodically during operator control. */ + @Override + public void teleopPeriodic() {} + + @Override + public void testInit() { + // Cancels all running commands at the start of test mode. + CommandScheduler.getInstance().cancelAll(); + } + + /** This function is called periodically during test mode. */ + @Override + public void testPeriodic() {} + + /** This function is called once when the robot is first started up. */ + @Override + public void simulationInit() {} + + /** This function is called periodically whilst in simulation. */ + @Override + public void simulationPeriodic() {} +} diff --git a/src/main/java/frc/robot/RobotContainer.java b/src/main/java/frc/robot/RobotContainer.java new file mode 100644 index 0000000..a58605f --- /dev/null +++ b/src/main/java/frc/robot/RobotContainer.java @@ -0,0 +1,82 @@ +// 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.arm.ArmPosition; +import frc.robot.subsystems.Arm; +import frc.robot.subsystems.Claw; +import edu.wpi.first.wpilibj.Preferences; +import edu.wpi.first.wpilibj2.command.Command; +import edu.wpi.first.wpilibj2.command.Commands; +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 { + + private final CommandXboxController m_driverController = new CommandXboxController(OperatorConstants.kDriverControllerPort); + private final CommandXboxController m_auxController = new CommandXboxController(OperatorConstants.kAuxDriverControllerPort); + + private Arm m_arm; + private Claw m_claw; + + /** The container for the robot. Contains subsystems, OI devices, and commands. */ + public RobotContainer() { + Preferences.removeAll(); + m_arm = new Arm(); + m_claw = new Claw(); + // 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() { + m_auxController.leftBumper().onTrue(m_claw.runToggleClaw()); + + m_auxController.leftStick().onTrue(m_arm.runLowerTest()); + m_auxController.leftStick().onFalse(m_arm.runCutMotors()); + m_auxController.rightStick().onTrue(m_arm.runUpperTest()); + m_auxController.rightStick().onFalse(m_arm.runCutMotors()); + + m_auxController.rightTrigger().onTrue(m_arm.runToSetpoint()); + m_auxController.rightTrigger().onFalse(m_arm.runGetOffSetpoint()); + + m_auxController.b().onTrue(m_arm.runSetArmPosition(ArmPosition.HOME)); + m_auxController.y().onTrue(m_arm.runSetArmPosition(ArmPosition.SUBSTATION)); + // m_auxController.a().onTrue(m_arm.runSetArmPosition(ArmPosition.LOW)); + // m_auxController.x().onTrue(m_arm.runSetArmPosition(ArmPosition.HIGH)); + m_auxController.rightBumper().onTrue(m_arm.runSetArmPosition(ArmPosition.BACK)); + + m_auxController.povUpLeft().whileTrue(m_arm.runBumpLower(-0.1)); + m_auxController.povDownLeft().whileTrue(m_arm.runBumpLower(0.1)); + + m_auxController.povUpRight().whileTrue(m_arm.runBumpUpper(-0.1)); + m_auxController.povDownRight().whileTrue(m_arm.runBumpUpper(0.1)); + } + + /** + * 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 Commands.run(() -> {}); + } +} diff --git a/src/main/java/frc/robot/commands/Autos.java b/src/main/java/frc/robot/commands/Autos.java new file mode 100644 index 0000000..63f6629 --- /dev/null +++ b/src/main/java/frc/robot/commands/Autos.java @@ -0,0 +1,19 @@ +// 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 edu.wpi.first.wpilibj2.command.CommandBase; +import edu.wpi.first.wpilibj2.command.Commands; + +public final class Autos { + /** Example static factory for an autonomous command. */ + // public static CommandBase exampleAuto(ExampleSubsystem subsystem) { + // return Commands.sequence(subsystem.exampleMethodCommand(), new ExampleCommand(subsystem)); + // } + + // private Autos() { + // throw new UnsupportedOperationException("This is a utility class!"); + // } +} diff --git a/src/main/java/frc/robot/commands/arm/ArmFF.java b/src/main/java/frc/robot/commands/arm/ArmFF.java new file mode 100644 index 0000000..bd0a80c --- /dev/null +++ b/src/main/java/frc/robot/commands/arm/ArmFF.java @@ -0,0 +1,183 @@ +// 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. + +// Edited by Team 178 for adjustable constants + +package frc.robot.commands.arm; + +/** + * A helper class that computes feedforward outputs for a simple arm (modeled as a motor acting + * against the force of gravity on a beam suspended at an angle). + */ +public class ArmFF { + private double ks; + private double kg; + private double kv; + private double ka; + + /** + * Creates a new ArmFF with the specified gains. Units of the gain values will dictate + * units of the computed feedforward. + * + * @param ks The static gain. + * @param kg The gravity gain. + * @param kv The velocity gain. + * @param ka The acceleration gain. + */ + public ArmFF(double ks, double kg, double kv, double ka) { + this.ks = ks; + this.kg = kg; + this.kv = kv; + this.ka = ka; + } + + /** + * Creates a new ArmFF with the specified gains. Acceleration gain is defaulted to zero. + * Units of the gain values will dictate units of the computed feedforward. + * + * @param ks The static gain. + * @param kg The gravity gain. + * @param kv The velocity gain. + */ + public ArmFF(double ks, double kg, double kv) { + this(ks, kg, kv, 0); + } + + /** + * Calculates the feedforward from the gains and setpoints. + * + * @param positionRadians The position (angle) setpoint. This angle should be measured from the + * horizontal (i.e. if the provided angle is 0, the arm should be parallel with the floor). If + * your encoder does not follow this convention, an offset should be added. + * @param velocityRadPerSec The velocity setpoint. + * @param accelRadPerSecSquared The acceleration setpoint. + * @return The computed feedforward. + */ + public double calculate( + double positionRadians, double velocityRadPerSec, double accelRadPerSecSquared) { + return ks * Math.signum(velocityRadPerSec) + + kg * Math.cos(positionRadians) + + kv * velocityRadPerSec + + ka * accelRadPerSecSquared; + } + + /** + * Calculates the feedforward from the gains and velocity setpoint (acceleration is assumed to be + * zero). + * + * @param positionRadians The position (angle) setpoint. This angle should be measured from the + * horizontal (i.e. if the provided angle is 0, the arm should be parallel with the floor). If + * your encoder does not follow this convention, an offset should be added. + * @param velocity The velocity setpoint. + * @return The computed feedforward. + */ + public double calculate(double positionRadians, double velocity) { + return calculate(positionRadians, velocity, 0); + } + + // Rearranging the main equation from the calculate() method yields the + // formulas for the methods below: + + /** + * Calculates the maximum achievable velocity given a maximum voltage supply, a position, and an + * acceleration. Useful for ensuring that velocity and acceleration constraints for a trapezoidal + * profile are simultaneously achievable - enter the acceleration constraint, and this will give + * you a simultaneously-achievable velocity constraint. + * + * @param maxVoltage The maximum voltage that can be supplied to the arm. + * @param angle The angle of the arm. This angle should be measured from the horizontal (i.e. if + * the provided angle is 0, the arm should be parallel with the floor). If your encoder does + * not follow this convention, an offset should be added. + * @param acceleration The acceleration of the arm. + * @return The maximum possible velocity at the given acceleration and angle. + */ + public double maxAchievableVelocity(double maxVoltage, double angle, double acceleration) { + // Assume max velocity is positive + return (maxVoltage - ks - Math.cos(angle) * kg - acceleration * ka) / kv; + } + + /** + * Calculates the minimum achievable velocity given a maximum voltage supply, a position, and an + * acceleration. Useful for ensuring that velocity and acceleration constraints for a trapezoidal + * profile are simultaneously achievable - enter the acceleration constraint, and this will give + * you a simultaneously-achievable velocity constraint. + * + * @param maxVoltage The maximum voltage that can be supplied to the arm. + * @param angle The angle of the arm. This angle should be measured from the horizontal (i.e. if + * the provided angle is 0, the arm should be parallel with the floor). If your encoder does + * not follow this convention, an offset should be added. + * @param acceleration The acceleration of the arm. + * @return The minimum possible velocity at the given acceleration and angle. + */ + public double minAchievableVelocity(double maxVoltage, double angle, double acceleration) { + // Assume min velocity is negative, ks flips sign + return (-maxVoltage + ks - Math.cos(angle) * kg - acceleration * ka) / kv; + } + + /** + * Calculates the maximum achievable acceleration given a maximum voltage supply, a position, and + * a velocity. Useful for ensuring that velocity and acceleration constraints for a trapezoidal + * profile are simultaneously achievable - enter the velocity constraint, and this will give you a + * simultaneously-achievable acceleration constraint. + * + * @param maxVoltage The maximum voltage that can be supplied to the arm. + * @param angle The angle of the arm. This angle should be measured from the horizontal (i.e. if + * the provided angle is 0, the arm should be parallel with the floor). If your encoder does + * not follow this convention, an offset should be added. + * @param velocity The velocity of the arm. + * @return The maximum possible acceleration at the given velocity. + */ + public double maxAchievableAcceleration(double maxVoltage, double angle, double velocity) { + return (maxVoltage - ks * Math.signum(velocity) - Math.cos(angle) * kg - velocity * kv) / ka; + } + + /** + * Calculates the minimum achievable acceleration given a maximum voltage supply, a position, and + * a velocity. Useful for ensuring that velocity and acceleration constraints for a trapezoidal + * profile are simultaneously achievable - enter the velocity constraint, and this will give you a + * simultaneously-achievable acceleration constraint. + * + * @param maxVoltage The maximum voltage that can be supplied to the arm. + * @param angle The angle of the arm. This angle should be measured from the horizontal (i.e. if + * the provided angle is 0, the arm should be parallel with the floor). If your encoder does + * not follow this convention, an offset should be added. + * @param velocity The velocity of the arm. + * @return The minimum possible acceleration at the given velocity. + */ + public double minAchievableAcceleration(double maxVoltage, double angle, double velocity) { + return maxAchievableAcceleration(-maxVoltage, angle, velocity); + } + + public double getS() { + return ks; + } + + public double getG() { + return kg; + } + + public double getV() { + return kv; + } + + public double getA() { + return ka; + } + + public void setS(double ks) { + this.ks = ks; + } + + public void setG(double kg) { + this.kg = kg; + } + + public void setV(double kv) { + this.kv = kv; + } + + public void setA(double ka) { + this.ka = ka; + } +} diff --git a/src/main/java/frc/robot/commands/arm/ArmPID.java b/src/main/java/frc/robot/commands/arm/ArmPID.java new file mode 100644 index 0000000..4cced28 --- /dev/null +++ b/src/main/java/frc/robot/commands/arm/ArmPID.java @@ -0,0 +1,388 @@ +// 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. + +// Edited by Team 178 for resettable m_totalError + +package frc.robot.commands.arm; + +import edu.wpi.first.math.MathSharedStore; +import edu.wpi.first.math.MathUsageId; +import edu.wpi.first.math.MathUtil; +import edu.wpi.first.util.sendable.Sendable; +import edu.wpi.first.util.sendable.SendableBuilder; +import edu.wpi.first.util.sendable.SendableRegistry; + +/** Implements a PID control loop. */ +public class ArmPID implements Sendable, AutoCloseable { + private static int instances; + + // Factor for "proportional" control + private double m_kp; + + // Factor for "integral" control + private double m_ki; + + // Factor for "derivative" control + private double m_kd; + + // The period (in seconds) of the loop that calls the controller + private final double m_period; + + private double m_maximumIntegral = 1.0; + + private double m_minimumIntegral = -1.0; + + private double m_maximumInput; + + private double m_minimumInput; + + // Do the endpoints wrap around? e.g. Absolute encoder + private boolean m_continuous; + + // The error at the time of the most recent call to calculate() + private double m_positionError; + private double m_velocityError; + + // The error at the time of the second-most-recent call to calculate() (used to compute velocity) + private double m_prevError; + + // The sum of the errors for use in the integral calc + private double m_totalError; + + // The error that is considered at setpoint. + private double m_positionTolerance = 0.05; + private double m_velocityTolerance = Double.POSITIVE_INFINITY; + + private double m_setpoint; + private double m_measurement; + + private boolean m_haveMeasurement; + private boolean m_haveSetpoint; + + /** + * Allocates a PIDController with the given constants for kp, ki, and kd and a default period of + * 0.02 seconds. + * + * @param kp The proportional coefficient. + * @param ki The integral coefficient. + * @param kd The derivative coefficient. + */ + public ArmPID(double kp, double ki, double kd) { + this(kp, ki, kd, 0.02); + } + + /** + * Allocates a PIDController with the given constants for kp, ki, and kd. + * + * @param kp The proportional coefficient. + * @param ki The integral coefficient. + * @param kd The derivative coefficient. + * @param period The period between controller updates in seconds. Must be non-zero and positive. + */ + public ArmPID(double kp, double ki, double kd, double period) { + m_kp = kp; + m_ki = ki; + m_kd = kd; + + if (period <= 0) { + throw new IllegalArgumentException("Controller period must be a non-zero positive number!"); + } + m_period = period; + + instances++; + SendableRegistry.addLW(this, "PIDController", instances); + + MathSharedStore.reportUsage(MathUsageId.kController_PIDController2, instances); + } + + @Override + public void close() { + SendableRegistry.remove(this); + } + + /** + * Sets the PID Controller gain parameters. + * + *
Set the proportional, integral, and differential coefficients. + * + * @param kp The proportional coefficient. + * @param ki The integral coefficient. + * @param kd The derivative coefficient. + */ + public void setPID(double kp, double ki, double kd) { + m_kp = kp; + m_ki = ki; + m_kd = kd; + } + + /** + * Sets the Proportional coefficient of the PID controller gain. + * + * @param kp proportional coefficient + */ + public void setP(double kp) { + m_kp = kp; + } + + /** + * Sets the Integral coefficient of the PID controller gain. + * + * @param ki integral coefficient + */ + public void setI(double ki) { + m_ki = ki; + } + + /** + * Sets the Differential coefficient of the PID controller gain. + * + * @param kd differential coefficient + */ + public void setD(double kd) { + m_kd = kd; + } + + /** + * Get the Proportional coefficient. + * + * @return proportional coefficient + */ + public double getP() { + return m_kp; + } + + /** + * Get the Integral coefficient. + * + * @return integral coefficient + */ + public double getI() { + return m_ki; + } + + /** + * Get the Differential coefficient. + * + * @return differential coefficient + */ + public double getD() { + return m_kd; + } + + /** + * Returns the period of this controller. + * + * @return the period of the controller. + */ + public double getPeriod() { + return m_period; + } + + /** + * Returns the position tolerance of this controller. + * + * @return the position tolerance of the controller. + */ + public double getPositionTolerance() { + return m_positionTolerance; + } + + /** + * Returns the velocity tolerance of this controller. + * + * @return the velocity tolerance of the controller. + */ + public double getVelocityTolerance() { + return m_velocityTolerance; + } + + /** + * Sets the setpoint for the PIDController. + * + * @param setpoint The desired setpoint. + */ + public void setSetpoint(double setpoint) { + m_setpoint = setpoint; + m_haveSetpoint = true; + + if (m_continuous) { + double errorBound = (m_maximumInput - m_minimumInput) / 2.0; + m_positionError = MathUtil.inputModulus(m_setpoint - m_measurement, -errorBound, errorBound); + } else { + m_positionError = m_setpoint - m_measurement; + } + + m_velocityError = (m_positionError - m_prevError) / m_period; + } + + /** + * Returns the current setpoint of the PIDController. + * + * @return The current setpoint. + */ + public double getSetpoint() { + return m_setpoint; + } + + /** + * Returns true if the error is within the tolerance of the setpoint. + * + *
This will return false until at least one input value has been computed. + * + * @return Whether the error is within the acceptable bounds. + */ + public boolean atSetpoint() { + return m_haveMeasurement + && m_haveSetpoint + && Math.abs(m_positionError) < m_positionTolerance + && Math.abs(m_velocityError) < m_velocityTolerance; + } + + /** + * Enables continuous input. + * + *
Rather then using the max and min input range as constraints, it considers them to be the + * same point and automatically calculates the shortest route to the setpoint. + * + * @param minimumInput The minimum value expected from the input. + * @param maximumInput The maximum value expected from the input. + */ + public void enableContinuousInput(double minimumInput, double maximumInput) { + m_continuous = true; + m_minimumInput = minimumInput; + m_maximumInput = maximumInput; + } + + /** Disables continuous input. */ + public void disableContinuousInput() { + m_continuous = false; + } + + /** + * Returns true if continuous input is enabled. + * + * @return True if continuous input is enabled. + */ + public boolean isContinuousInputEnabled() { + return m_continuous; + } + + /** + * Sets the minimum and maximum values for the integrator. + * + *
When the cap is reached, the integrator value is added to the controller output rather than + * the integrator value times the integral gain. + * + * @param minimumIntegral The minimum value of the integrator. + * @param maximumIntegral The maximum value of the integrator. + */ + public void setIntegratorRange(double minimumIntegral, double maximumIntegral) { + m_minimumIntegral = minimumIntegral; + m_maximumIntegral = maximumIntegral; + } + + /** + * Sets the error which is considered tolerable for use with atSetpoint(). + * + * @param positionTolerance Position error which is tolerable. + */ + public void setTolerance(double positionTolerance) { + setTolerance(positionTolerance, Double.POSITIVE_INFINITY); + } + + /** + * Sets the error which is considered tolerable for use with atSetpoint(). + * + * @param positionTolerance Position error which is tolerable. + * @param velocityTolerance Velocity error which is tolerable. + */ + public void setTolerance(double positionTolerance, double velocityTolerance) { + m_positionTolerance = positionTolerance; + m_velocityTolerance = velocityTolerance; + } + + /** + * Returns the difference between the setpoint and the measurement. + * + * @return The error. + */ + public double getPositionError() { + return m_positionError; + } + + /** + * Returns the velocity error. + * + * @return The velocity error. + */ + public double getVelocityError() { + return m_velocityError; + } + + /** + * Returns the next output of the PID controller. + * + * @param measurement The current measurement of the process variable. + * @param setpoint The new setpoint of the controller. + * @return The next controller output. + */ + public double calculate(double measurement, double setpoint) { + m_setpoint = setpoint; + m_haveSetpoint = true; + return calculate(measurement); + } + + /** + * Returns the next output of the PID controller. + * + * @param measurement The current measurement of the process variable. + * @return The next controller output. + */ + public double calculate(double measurement) { + m_measurement = measurement; + m_prevError = m_positionError; + m_haveMeasurement = true; + + if (m_continuous) { + double errorBound = (m_maximumInput - m_minimumInput) / 2.0; + m_positionError = MathUtil.inputModulus(m_setpoint - m_measurement, -errorBound, errorBound); + } else { + m_positionError = m_setpoint - m_measurement; + } + + m_velocityError = (m_positionError - m_prevError) / m_period; + + if (m_ki != 0) { + m_totalError = + MathUtil.clamp( + m_totalError + m_positionError * m_period, + m_minimumIntegral / m_ki, + m_maximumIntegral / m_ki); + } + + return m_kp * m_positionError + m_ki * m_totalError + m_kd * m_velocityError; + } + + /** Resets the previous error and the integral term. */ + public void reset() { + m_positionError = 0; + m_prevError = 0; + m_totalError = 0; + m_velocityError = 0; + m_haveMeasurement = false; + } + + public void resetIntegralError() { + m_totalError = 0; + } + + @Override + public void initSendable(SendableBuilder builder) { + builder.setSmartDashboardType("PIDController"); + builder.addDoubleProperty("p", this::getP, this::setP); + builder.addDoubleProperty("i", this::getI, this::setI); + builder.addDoubleProperty("d", this::getD, this::setD); + builder.addDoubleProperty("setpoint", this::getSetpoint, this::setSetpoint); + } +} diff --git a/src/main/java/frc/robot/commands/arm/ArmPosition.java b/src/main/java/frc/robot/commands/arm/ArmPosition.java new file mode 100644 index 0000000..29acd7c --- /dev/null +++ b/src/main/java/frc/robot/commands/arm/ArmPosition.java @@ -0,0 +1,26 @@ +package frc.robot.commands.arm; + +public enum ArmPosition { + //! These values are not adjusted + HOME(309.897908, 342.843705), + SUBSTATION(240.671931, 293.881183), + // HIGH(2.976432, 3.154062), + // LOW(3.587507, 4.466632), + BACK(290, 315); + + private double lowerSetpoint; + private double upperSetpoint; + + private ArmPosition(double lowerSetpoint, double upperSetpoint) { + this.lowerSetpoint = lowerSetpoint; + this.upperSetpoint = upperSetpoint; + } + + public double getLowerSetpoint() { + return lowerSetpoint; + } + + public double getUpperSetpoint() { + return upperSetpoint; + } +} diff --git a/src/main/java/frc/robot/subsystems/Arm.java b/src/main/java/frc/robot/subsystems/Arm.java new file mode 100644 index 0000000..4a6c4d9 --- /dev/null +++ b/src/main/java/frc/robot/subsystems/Arm.java @@ -0,0 +1,237 @@ +package frc.robot.subsystems; + +import com.revrobotics.CANSparkMax; +import com.revrobotics.CANSparkMax.IdleMode; +import com.revrobotics.CANSparkMaxLowLevel.MotorType; + +import edu.wpi.first.math.MathUtil; +import edu.wpi.first.math.controller.PIDController; +import edu.wpi.first.math.util.Units; +import edu.wpi.first.wpilibj.DigitalInput; +import edu.wpi.first.wpilibj.DutyCycleEncoder; +import edu.wpi.first.wpilibj.Preferences; +import edu.wpi.first.wpilibj.smartdashboard.SmartDashboard; +import edu.wpi.first.wpilibj2.command.CommandBase; +import edu.wpi.first.wpilibj2.command.SubsystemBase; +import frc.robot.Constants.ArmConstants; +import frc.robot.commands.arm.ArmFF; +import frc.robot.commands.arm.ArmPID; +import frc.robot.commands.arm.ArmPosition; + +public class Arm extends SubsystemBase { + private CANSparkMax m_lowerMotor; + private CANSparkMax m_upperMotor; + + private DutyCycleEncoder m_lowerEncoder; + private DutyCycleEncoder m_upperEncoder; + + private ArmPID m_lowerPIDController; + private ArmPID m_upperPIDController; + private ArmFF m_lowerFFController; + private ArmFF m_upperFFController; + + private DigitalInput m_lowerLimit; + private DigitalInput m_upperLimit; + + private ArmPosition m_armPosition; + + private boolean toSetpoint; + + public Arm() { + ArmConstants.initArmPreferences(); + Preferences.initDouble("kLowerTestOutput", 0.1); + Preferences.initDouble("kUpperTestOutput", 0.1); + + m_lowerMotor = new CANSparkMax(ArmConstants.kLowerSparkPort, MotorType.kBrushless); + m_lowerEncoder = new DutyCycleEncoder(ArmConstants.kLowerEncoderChannel); + m_lowerLimit = new DigitalInput(ArmConstants.kLowerLimitChannel); + m_lowerPIDController = new ArmPID( + ArmConstants.getKLowerP(), + ArmConstants.getKLowerI(), + ArmConstants.getKLowerD() + ); + m_lowerFFController = new ArmFF( + ArmConstants.getKLowerS(), + ArmConstants.getKLowerG(), + ArmConstants.getKLowerV(), + ArmConstants.getKLowerA() + ); + + m_upperMotor = new CANSparkMax(ArmConstants.kUpperSparkPort, MotorType.kBrushless); + m_upperEncoder = new DutyCycleEncoder(ArmConstants.kUpperEncoderChannel); + m_upperLimit = new DigitalInput(ArmConstants.kUpperLimitChannel); + m_upperPIDController = new ArmPID( + ArmConstants.getKUpperP(), + ArmConstants.getKUpperI(), + ArmConstants.getKUpperD() + ); + m_upperFFController = new ArmFF( + ArmConstants.getKUpperS(), + ArmConstants.getKUpperG(), + ArmConstants.getKUpperV(), + ArmConstants.getKUpperA() + ); + + setArmPosition(ArmPosition.HOME); + + m_lowerMotor.restoreFactoryDefaults(); + m_upperMotor.restoreFactoryDefaults(); + + //! double check + m_lowerMotor.setInverted(false); + m_upperMotor.setInverted(false); + + setBrake(); + + //! double check how encoder class works + // m_lowerEncoder.reset(); + // m_upperEncoder.reset(); + + toSetpoint = false; + + } + + public void updateToPreferences() { + m_lowerPIDController.setP(ArmConstants.getKLowerP()); + m_lowerPIDController.setI(ArmConstants.getKLowerI()); + m_lowerPIDController.setD(ArmConstants.getKLowerD()); + + m_lowerFFController.setS(ArmConstants.getKLowerS()); + m_lowerFFController.setG(ArmConstants.getKLowerG()); + m_lowerFFController.setV(ArmConstants.getKLowerV()); + m_lowerFFController.setA(ArmConstants.getKLowerA()); + + m_upperPIDController.setP(ArmConstants.getKUpperP()); + m_upperPIDController.setI(ArmConstants.getKUpperI()); + m_upperPIDController.setD(ArmConstants.getKUpperD()); + + m_upperFFController.setS(ArmConstants.getKUpperS()); + m_upperFFController.setG(ArmConstants.getKUpperG()); + m_upperFFController.setV(ArmConstants.getKUpperV()); + m_upperFFController.setA(ArmConstants.getKUpperA()); + } + + public double getLowerPosition() { + return m_lowerEncoder.getAbsolutePosition() * 360; + } + + public double getUpperPosition() { + return m_upperEncoder.getAbsolutePosition() * 360; + } + + public void setBrake() { + m_lowerMotor.setIdleMode(IdleMode.kBrake); + m_upperMotor.setIdleMode(IdleMode.kBrake); + } + + public void setCoast() { + m_lowerMotor.setIdleMode(IdleMode.kCoast); + m_upperMotor.setIdleMode(IdleMode.kCoast); + } + + public void setArmPosition(ArmPosition armPosition) { + m_armPosition = armPosition; + m_lowerPIDController.resetIntegralError(); + m_upperPIDController.resetIntegralError(); + m_lowerPIDController.setSetpoint(m_armPosition.getLowerSetpoint()); + m_upperPIDController.setSetpoint(m_armPosition.getUpperSetpoint()); + } + + public CommandBase runLowerTest() { + return runOnce(() -> { + m_lowerMotor.setVoltage(Preferences.getDouble("kLowerTestOutput", 0)); + System.out.println("Lower motor test speed on."); + }); + } + + public CommandBase runUpperTest() { + return runOnce(() -> { + m_upperMotor.setVoltage(Preferences.getDouble("kUpperTestOutput", 0)); + System.out.println("Upper motor test speed on."); + }); + } + + public CommandBase runCutMotors() { + return runOnce(() -> { + m_lowerMotor.setVoltage(0); + m_upperMotor.setVoltage(0); + System.out.println("Arm motors off."); + }); + } + + public CommandBase runToSetpoint() { + return runOnce(() -> { + toSetpoint = true; + System.out.println("On setpoint."); + }); + } + + public CommandBase runGetOffSetpoint() { + return runOnce(() -> { + toSetpoint = false; + m_lowerMotor.setVoltage(0); + m_upperMotor.setVoltage(0); + System.out.println("Off setpoint."); + }); + } + + public CommandBase runSetArmPosition(ArmPosition newPosition) { + return runOnce(() -> { + setArmPosition(newPosition); + }); + } + + public CommandBase runBumpLower(double bump) { + return run(() -> { + m_lowerPIDController.resetIntegralError(); + m_lowerPIDController.setSetpoint(m_lowerPIDController.getSetpoint() + bump); + }); + } + + public CommandBase runBumpUpper(double bump) { + return run(() -> { + m_upperPIDController.resetIntegralError(); + m_upperPIDController.setSetpoint(m_upperPIDController.getSetpoint() + bump); + }); + } + + @Override + public void periodic() { + updateToPreferences(); + SmartDashboard.putNumber("Lower Raw Position", m_lowerEncoder.getAbsolutePosition()); + SmartDashboard.putNumber("Upper Raw Position", m_upperEncoder.getAbsolutePosition()); + SmartDashboard.putNumber("Lower Position", getLowerPosition()); + SmartDashboard.putNumber("Upper Position", getUpperPosition()); + SmartDashboard.putNumber("Lower Pos Offset", m_lowerEncoder.getPositionOffset()); + SmartDashboard.putNumber("Upper Pos Offset", m_upperEncoder.getPositionOffset()); + + SmartDashboard.putBoolean("Lower Home", m_lowerLimit.get()); + SmartDashboard.putBoolean("Upper Home", m_upperLimit.get()); + + SmartDashboard.putNumber("Lower Setpoint", m_lowerPIDController.getSetpoint()); + SmartDashboard.putNumber("Upper Setpoint", m_upperPIDController.getSetpoint()); + + double lowerPIDOutput = m_lowerPIDController.calculate(getLowerPosition()); + double upperPIDOutput = m_upperPIDController.calculate(getUpperPosition()); + + double lowerRadians = Units.degreesToRadians(m_lowerPIDController.getSetpoint() - ArmConstants.kLowerOffset); + double upperRadians = Units.degreesToRadians(m_upperPIDController.getSetpoint() - ArmConstants.kUpperOffset); + SmartDashboard.putNumber("LowerRadians", Math.cos(Units.degreesToRadians(getLowerPosition() - ArmConstants.kLowerOffset))); + SmartDashboard.putNumber("UpperRadians", Math.cos(Units.degreesToRadians(getUpperPosition() - ArmConstants.kUpperOffset))); + double lowerFFOutput = m_lowerFFController.calculate(lowerRadians, 0); + double upperFFOutput = m_upperFFController.calculate(upperRadians, 0); + + SmartDashboard.putNumber("Lower PID Output", lowerPIDOutput); + SmartDashboard.putNumber("Upper PID Output", upperPIDOutput); + SmartDashboard.putNumber("Lower FF Output", lowerFFOutput); + SmartDashboard.putNumber("Upper FF Output", upperFFOutput); + + if(toSetpoint) { + m_lowerMotor.setVoltage(MathUtil.clamp(lowerPIDOutput + lowerFFOutput, -ArmConstants.kLowerMaxVolts, ArmConstants.kLowerMaxVolts)); + m_upperMotor.setVoltage(MathUtil.clamp(upperPIDOutput + upperFFOutput, -ArmConstants.kUpperMaxVolts, ArmConstants.kUpperMaxVolts)); + } + } + + + +} diff --git a/src/main/java/frc/robot/subsystems/Claw.java b/src/main/java/frc/robot/subsystems/Claw.java new file mode 100644 index 0000000..8fe528f --- /dev/null +++ b/src/main/java/frc/robot/subsystems/Claw.java @@ -0,0 +1,24 @@ +package frc.robot.subsystems; + +import edu.wpi.first.wpilibj.PneumaticsModuleType; +import edu.wpi.first.wpilibj.Solenoid; +import edu.wpi.first.wpilibj2.command.CommandBase; +import edu.wpi.first.wpilibj2.command.SubsystemBase; +import frc.robot.Constants.ClawConstants; + +public class Claw extends SubsystemBase { + private Solenoid m_solenoid; + + public Claw() { + m_solenoid = new Solenoid(PneumaticsModuleType.CTREPCM, ClawConstants.kSolenoidPort); + m_solenoid.set(false); + } + + public void toggleClaw() { + m_solenoid.toggle(); + } + + public CommandBase runToggleClaw() { + return runOnce(() -> toggleClaw()); + } +} diff --git a/vendordeps/Phoenix.json b/vendordeps/Phoenix.json new file mode 100644 index 0000000..614dc3a --- /dev/null +++ b/vendordeps/Phoenix.json @@ -0,0 +1,423 @@ +{ + "fileName": "Phoenix.json", + "name": "CTRE-Phoenix (v5)", + "version": "5.31.0+23.2.2", + "frcYear": 2023, + "uuid": "ab676553-b602-441f-a38d-f1296eff6537", + "mavenUrls": [ + "https://maven.ctr-electronics.com/release/" + ], + "jsonUrl": "https://maven.ctr-electronics.com/release/com/ctre/phoenix/Phoenix5-frc2023-latest.json", + "javaDependencies": [ + { + "groupId": "com.ctre.phoenix", + "artifactId": "api-java", + "version": "5.31.0" + }, + { + "groupId": "com.ctre.phoenix", + "artifactId": "wpiapi-java", + "version": "5.31.0" + } + ], + "jniDependencies": [ + { + "groupId": "com.ctre.phoenix", + "artifactId": "cci", + "version": "5.31.0", + "isJar": false, + "skipInvalidPlatforms": true, + "validPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "linuxathena" + ], + "simMode": "hwsim" + }, + { + "groupId": "com.ctre.phoenix.sim", + "artifactId": "cci-sim", + "version": "5.31.0", + "isJar": false, + "skipInvalidPlatforms": true, + "validPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" + }, + { + "groupId": "com.ctre.phoenix6", + "artifactId": "tools", + "version": "23.2.2", + "isJar": false, + "skipInvalidPlatforms": true, + "validPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "linuxathena" + ], + "simMode": "hwsim" + }, + { + "groupId": "com.ctre.phoenix6.sim", + "artifactId": "tools-sim", + "version": "23.2.2", + "isJar": false, + "skipInvalidPlatforms": true, + "validPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" + }, + { + "groupId": "com.ctre.phoenix6.sim", + "artifactId": "simTalonSRX", + "version": "23.2.2", + "isJar": false, + "skipInvalidPlatforms": true, + "validPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" + }, + { + "groupId": "com.ctre.phoenix6.sim", + "artifactId": "simTalonFX", + "version": "23.2.2", + "isJar": false, + "skipInvalidPlatforms": true, + "validPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" + }, + { + "groupId": "com.ctre.phoenix6.sim", + "artifactId": "simVictorSPX", + "version": "23.2.2", + "isJar": false, + "skipInvalidPlatforms": true, + "validPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" + }, + { + "groupId": "com.ctre.phoenix6.sim", + "artifactId": "simPigeonIMU", + "version": "23.2.2", + "isJar": false, + "skipInvalidPlatforms": true, + "validPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" + }, + { + "groupId": "com.ctre.phoenix6.sim", + "artifactId": "simCANCoder", + "version": "23.2.2", + "isJar": false, + "skipInvalidPlatforms": true, + "validPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" + }, + { + "groupId": "com.ctre.phoenix6.sim", + "artifactId": "simProTalonFX", + "version": "23.2.2", + "isJar": false, + "skipInvalidPlatforms": true, + "validPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" + }, + { + "groupId": "com.ctre.phoenix6.sim", + "artifactId": "simProCANcoder", + "version": "23.2.2", + "isJar": false, + "skipInvalidPlatforms": true, + "validPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" + }, + { + "groupId": "com.ctre.phoenix6.sim", + "artifactId": "simProPigeon2", + "version": "23.2.2", + "isJar": false, + "skipInvalidPlatforms": true, + "validPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" + } + ], + "cppDependencies": [ + { + "groupId": "com.ctre.phoenix", + "artifactId": "wpiapi-cpp", + "version": "5.31.0", + "libName": "CTRE_Phoenix_WPI", + "headerClassifier": "headers", + "sharedLibrary": true, + "skipInvalidPlatforms": true, + "binaryPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "linuxathena" + ], + "simMode": "hwsim" + }, + { + "groupId": "com.ctre.phoenix", + "artifactId": "api-cpp", + "version": "5.31.0", + "libName": "CTRE_Phoenix", + "headerClassifier": "headers", + "sharedLibrary": true, + "skipInvalidPlatforms": true, + "binaryPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "linuxathena" + ], + "simMode": "hwsim" + }, + { + "groupId": "com.ctre.phoenix", + "artifactId": "cci", + "version": "5.31.0", + "libName": "CTRE_PhoenixCCI", + "headerClassifier": "headers", + "sharedLibrary": true, + "skipInvalidPlatforms": true, + "binaryPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "linuxathena" + ], + "simMode": "hwsim" + }, + { + "groupId": "com.ctre.phoenix6", + "artifactId": "tools", + "version": "23.2.2", + "libName": "CTRE_PhoenixTools", + "headerClassifier": "headers", + "sharedLibrary": true, + "skipInvalidPlatforms": true, + "binaryPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "linuxathena" + ], + "simMode": "hwsim" + }, + { + "groupId": "com.ctre.phoenix.sim", + "artifactId": "wpiapi-cpp-sim", + "version": "5.31.0", + "libName": "CTRE_Phoenix_WPISim", + "headerClassifier": "headers", + "sharedLibrary": true, + "skipInvalidPlatforms": true, + "binaryPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" + }, + { + "groupId": "com.ctre.phoenix.sim", + "artifactId": "api-cpp-sim", + "version": "5.31.0", + "libName": "CTRE_PhoenixSim", + "headerClassifier": "headers", + "sharedLibrary": true, + "skipInvalidPlatforms": true, + "binaryPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" + }, + { + "groupId": "com.ctre.phoenix.sim", + "artifactId": "cci-sim", + "version": "5.31.0", + "libName": "CTRE_PhoenixCCISim", + "headerClassifier": "headers", + "sharedLibrary": true, + "skipInvalidPlatforms": true, + "binaryPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" + }, + { + "groupId": "com.ctre.phoenix6.sim", + "artifactId": "tools-sim", + "version": "23.2.2", + "libName": "CTRE_PhoenixTools_Sim", + "headerClassifier": "headers", + "sharedLibrary": true, + "skipInvalidPlatforms": true, + "binaryPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" + }, + { + "groupId": "com.ctre.phoenix6.sim", + "artifactId": "simTalonSRX", + "version": "23.2.2", + "libName": "CTRE_SimTalonSRX", + "headerClassifier": "headers", + "sharedLibrary": true, + "skipInvalidPlatforms": true, + "binaryPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" + }, + { + "groupId": "com.ctre.phoenix6.sim", + "artifactId": "simTalonFX", + "version": "23.2.2", + "libName": "CTRE_SimTalonFX", + "headerClassifier": "headers", + "sharedLibrary": true, + "skipInvalidPlatforms": true, + "binaryPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" + }, + { + "groupId": "com.ctre.phoenix6.sim", + "artifactId": "simVictorSPX", + "version": "23.2.2", + "libName": "CTRE_SimVictorSPX", + "headerClassifier": "headers", + "sharedLibrary": true, + "skipInvalidPlatforms": true, + "binaryPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" + }, + { + "groupId": "com.ctre.phoenix6.sim", + "artifactId": "simPigeonIMU", + "version": "23.2.2", + "libName": "CTRE_SimPigeonIMU", + "headerClassifier": "headers", + "sharedLibrary": true, + "skipInvalidPlatforms": true, + "binaryPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" + }, + { + "groupId": "com.ctre.phoenix6.sim", + "artifactId": "simCANCoder", + "version": "23.2.2", + "libName": "CTRE_SimCANCoder", + "headerClassifier": "headers", + "sharedLibrary": true, + "skipInvalidPlatforms": true, + "binaryPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" + }, + { + "groupId": "com.ctre.phoenix6.sim", + "artifactId": "simProTalonFX", + "version": "23.2.2", + "libName": "CTRE_SimProTalonFX", + "headerClassifier": "headers", + "sharedLibrary": true, + "skipInvalidPlatforms": true, + "binaryPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" + }, + { + "groupId": "com.ctre.phoenix6.sim", + "artifactId": "simProCANcoder", + "version": "23.2.2", + "libName": "CTRE_SimProCANcoder", + "headerClassifier": "headers", + "sharedLibrary": true, + "skipInvalidPlatforms": true, + "binaryPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" + }, + { + "groupId": "com.ctre.phoenix6.sim", + "artifactId": "simProPigeon2", + "version": "23.2.2", + "libName": "CTRE_SimProPigeon2", + "headerClassifier": "headers", + "sharedLibrary": true, + "skipInvalidPlatforms": true, + "binaryPlatforms": [ + "windowsx86-64", + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" + } + ] +} \ No newline at end of file diff --git a/vendordeps/REVLib.json b/vendordeps/REVLib.json new file mode 100644 index 0000000..f2d0b7d --- /dev/null +++ b/vendordeps/REVLib.json @@ -0,0 +1,73 @@ +{ + "fileName": "REVLib.json", + "name": "REVLib", + "version": "2023.1.3", + "uuid": "3f48eb8c-50fe-43a6-9cb7-44c86353c4cb", + "mavenUrls": [ + "https://maven.revrobotics.com/" + ], + "jsonUrl": "https://software-metadata.revrobotics.com/REVLib-2023.json", + "javaDependencies": [ + { + "groupId": "com.revrobotics.frc", + "artifactId": "REVLib-java", + "version": "2023.1.3" + } + ], + "jniDependencies": [ + { + "groupId": "com.revrobotics.frc", + "artifactId": "REVLib-driver", + "version": "2023.1.3", + "skipInvalidPlatforms": true, + "isJar": false, + "validPlatforms": [ + "windowsx86-64", + "windowsx86", + "linuxarm64", + "linuxx86-64", + "linuxathena", + "linuxarm32", + "osxuniversal" + ] + } + ], + "cppDependencies": [ + { + "groupId": "com.revrobotics.frc", + "artifactId": "REVLib-cpp", + "version": "2023.1.3", + "libName": "REVLib", + "headerClassifier": "headers", + "sharedLibrary": false, + "skipInvalidPlatforms": true, + "binaryPlatforms": [ + "windowsx86-64", + "windowsx86", + "linuxarm64", + "linuxx86-64", + "linuxathena", + "linuxarm32", + "osxuniversal" + ] + }, + { + "groupId": "com.revrobotics.frc", + "artifactId": "REVLib-driver", + "version": "2023.1.3", + "libName": "REVLibDriver", + "headerClassifier": "headers", + "sharedLibrary": false, + "skipInvalidPlatforms": true, + "binaryPlatforms": [ + "windowsx86-64", + "windowsx86", + "linuxarm64", + "linuxx86-64", + "linuxathena", + "linuxarm32", + "osxuniversal" + ] + } + ] +} \ No newline at end of file diff --git a/vendordeps/WPILibNewCommands.json b/vendordeps/WPILibNewCommands.json new file mode 100644 index 0000000..bd535bf --- /dev/null +++ b/vendordeps/WPILibNewCommands.json @@ -0,0 +1,37 @@ +{ + "fileName": "WPILibNewCommands.json", + "name": "WPILib-New-Commands", + "version": "1.0.0", + "uuid": "111e20f7-815e-48f8-9dd6-e675ce75b266", + "mavenUrls": [], + "jsonUrl": "", + "javaDependencies": [ + { + "groupId": "edu.wpi.first.wpilibNewCommands", + "artifactId": "wpilibNewCommands-java", + "version": "wpilib" + } + ], + "jniDependencies": [], + "cppDependencies": [ + { + "groupId": "edu.wpi.first.wpilibNewCommands", + "artifactId": "wpilibNewCommands-cpp", + "version": "wpilib", + "libName": "wpilibNewCommands", + "headerClassifier": "headers", + "sourcesClassifier": "sources", + "sharedLibrary": true, + "skipInvalidPlatforms": true, + "binaryPlatforms": [ + "linuxathena", + "linuxarm32", + "linuxarm64", + "windowsx86-64", + "windowsx86", + "linuxx86-64", + "osxuniversal" + ] + } + ] +}