From 18dbf67dc03d4011ece74621dcc56661b07d557f Mon Sep 17 00:00:00 2001 From: 66945 <54561572+66945@users.noreply.github.com> Date: Tue, 1 Nov 2022 17:43:01 -0600 Subject: [PATCH 1/4] Churro --- .idea/.gitignore | 3 + .idea/gradle.xml | 17 + .idea/misc.xml | 4 + .idea/vcs.xml | 6 + src/main/java/frc4388/robot/Constants.java | 46 +++ .../frc4388/robot/subsystems/SwerveDrive.java | 315 ++++++++++++++++++ .../robot/subsystems/SwerveModule.java | 181 ++++++++++ 7 files changed, 572 insertions(+) create mode 100644 .idea/.gitignore create mode 100644 .idea/gradle.xml create mode 100644 .idea/misc.xml create mode 100644 .idea/vcs.xml create mode 100644 src/main/java/frc4388/robot/subsystems/SwerveDrive.java create mode 100644 src/main/java/frc4388/robot/subsystems/SwerveModule.java diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..26d3352 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,3 @@ +# Default ignored files +/shelf/ +/workspace.xml diff --git a/.idea/gradle.xml b/.idea/gradle.xml new file mode 100644 index 0000000..4edc9d5 --- /dev/null +++ b/.idea/gradle.xml @@ -0,0 +1,17 @@ + + + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..6ed36dd --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..35eb1dd --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/src/main/java/frc4388/robot/Constants.java b/src/main/java/frc4388/robot/Constants.java index d92d66b..84bd57a 100644 --- a/src/main/java/frc4388/robot/Constants.java +++ b/src/main/java/frc4388/robot/Constants.java @@ -18,6 +18,52 @@ import frc4388.utility.LEDPatterns; * constants are needed, to reduce verbosity. */ public final class Constants { + public static final class SwerveDriveConstants { + public static final double ROTATION_SPEED = 0.1; + public static final double WHEEL_SPEED = 0.1; + public static final double WIDTH = 22; + public static final double HEIGHT = 22; + public static final double JOYSTICK_TO_METERS_PER_SECOND = 5; + public static final double MAX_SPEED_FEET_PER_SEC = 16; + public static final double SPEED_FEET_PER_SECOND_AT_FULL_POWER = 20; + public static final int LEFT_FRONT_STEER_CAN_ID = 2; + public static final int LEFT_FRONT_WHEEL_CAN_ID = 3; + public static final int RIGHT_FRONT_STEER_CAN_ID = 4; + public static final int RIGHT_FRONT_WHEEL_CAN_ID = 5; + public static final int LEFT_BACK_STEER_CAN_ID = 6; + public static final int LEFT_BACK_WHEEL_CAN_ID = 7; + public static final int RIGHT_BACK_STEER_CAN_ID = 8; + public static final int RIGHT_BACK_WHEEL_CAN_ID = 9; + public static final int LEFT_FRONT_STEER_CAN_ENCODER_ID = 10; + public static final int RIGHT_FRONT_STEER_CAN_ENCODER_ID = 11; + public static final int LEFT_BACK_STEER_CAN_ENCODER_ID = 12; + public static final int RIGHT_BACK_STEER_CAN_ENCODER_ID = 13; + // ofsets are in degrees + //ofsets are in degrees + // public static final double LEFT_FRONT_ENCODER_OFFSET = 181.494141; + // public static final double RIGHT_FRONT_ENCODER_OFFSET = 360. - 59.238281; + // public static final double LEFT_BACK_ENCODER_OFFSET = 360. - 128.144531; + // public static final double RIGHT_BACK_ENCODER_OFFSET = 0.933594; + public static final double LEFT_FRONT_ENCODER_OFFSET = 180.0; + public static final double RIGHT_FRONT_ENCODER_OFFSET = 300.0; + public static final double LEFT_BACK_ENCODER_OFFSET = 360.0 - 128.0; + public static final double RIGHT_BACK_ENCODER_OFFSET = 0.0; + + // swerve PID constants + public static final int SWERVE_SLOT_IDX = 0; + public static final int SWERVE_PID_LOOP_IDX = 1; + public static final int SWERVE_TIMEOUT_MS = 30; + public static final Gains SWERVE_GAINS = new Gains(1.0, 0.0, 0.0, 0.0, 0, 1.0); + + // swerve configuration + public static final double NEUTRAL_DEADBAND = 0.04; + public static final double OPEN_LOOP_RAMP_RATE = 0.2; + public static final int REMOTE_0 = 0; + + // misc + public static final int SMARTDASHBOARD_UPDATE_FRAME = 2; + } + public static final class DriveConstants { public static final int DRIVE_LEFT_FRONT_CAN_ID = 2; public static final int DRIVE_RIGHT_FRONT_CAN_ID = 4; diff --git a/src/main/java/frc4388/robot/subsystems/SwerveDrive.java b/src/main/java/frc4388/robot/subsystems/SwerveDrive.java new file mode 100644 index 0000000..34687d9 --- /dev/null +++ b/src/main/java/frc4388/robot/subsystems/SwerveDrive.java @@ -0,0 +1,315 @@ +// 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 frc4388.robot.subsystems; + +import com.ctre.phoenix.sensors.WPI_Pigeon2; + +import edu.wpi.first.math.VecBuilder; +import edu.wpi.first.math.estimator.SwerveDrivePoseEstimator; +import edu.wpi.first.math.geometry.Pose2d; +import edu.wpi.first.math.geometry.Rotation2d; +import edu.wpi.first.math.geometry.Translation2d; +import edu.wpi.first.math.kinematics.ChassisSpeeds; +import edu.wpi.first.math.kinematics.SwerveDriveKinematics; +import edu.wpi.first.math.kinematics.SwerveDriveOdometry; +import edu.wpi.first.math.kinematics.SwerveModuleState; +import edu.wpi.first.math.util.Units; +import edu.wpi.first.wpilibj.smartdashboard.Field2d; +import edu.wpi.first.wpilibj.smartdashboard.SmartDashboard; +import edu.wpi.first.wpilibj2.command.SubsystemBase; +import frc4388.robot.Constants.OIConstants; +import frc4388.robot.Constants.SwerveDriveConstants; +import frc4388.utility.Gains; + +public class SwerveDrive extends SubsystemBase { + + private SwerveModule m_leftFront; + private SwerveModule m_leftBack; + private SwerveModule m_rightFront; + private SwerveModule m_rightBack; + + double halfWidth = SwerveDriveConstants.WIDTH / 2.d; + double halfHeight = SwerveDriveConstants.HEIGHT / 2.d; + + public static Gains m_swerveGains = SwerveDriveConstants.SWERVE_GAINS; + + Translation2d m_frontLeftLocation = + new Translation2d( + Units.inchesToMeters(halfHeight), + Units.inchesToMeters(halfWidth)); + Translation2d m_frontRightLocation = + new Translation2d( + Units.inchesToMeters(halfHeight), + Units.inchesToMeters(-halfWidth)); + Translation2d m_backLeftLocation = + new Translation2d( + Units.inchesToMeters(-halfHeight), + Units.inchesToMeters(halfWidth)); + Translation2d m_backRightLocation = + new Translation2d( + Units.inchesToMeters(-halfHeight), + Units.inchesToMeters(-halfWidth)); + + public SwerveDriveKinematics m_kinematics = new SwerveDriveKinematics(m_frontLeftLocation, m_frontRightLocation, + m_backLeftLocation, m_backRightLocation); + + public SwerveModule[] modules; + public WPI_Pigeon2 m_gyro; + + public SwerveDriveOdometry m_odometry; + // public SwerveDriveOdometry m_odometry; + + public double speedAdjust = SwerveDriveConstants.JOYSTICK_TO_METERS_PER_SECOND_SLOW; + public boolean ignoreAngles; + public Rotation2d rotTarget = new Rotation2d(); + private ChassisSpeeds chassisSpeeds = new ChassisSpeeds(); + + private final Field2d m_field = new Field2d(); + + public SwerveDrive(SwerveModule leftFront, SwerveModule leftBack, SwerveModule rightFront, SwerveModule rightBack, + WPI_Pigeon2 gyro) { + + m_leftFront = leftFront; + m_leftBack = leftBack; + m_rightFront = rightFront; + m_rightBack = rightBack; + m_gyro = gyro; + + modules = new SwerveModule[] {m_leftFront, m_rightFront, m_leftBack, m_rightBack}; + + // m_poseEstimator = new SwerveDrivePoseEstimator( + // getRegGyro(),//m_gyro.getRotation2d(), + // new Pose2d(), + // m_kinematics, + // VecBuilder.fill(1.0, 1.0, Units.degreesToRadians(1)), // TODO: tune + // VecBuilder.fill(Units.degreesToRadians(1)), // TODO: tune + // VecBuilder.fill(1.0, 1.0, Units.degreesToRadians(1))); // TODO: tune + + m_odometry = new SwerveDriveOdometry(m_kinematics, m_gyro.getRotation2d()); + + m_gyro.reset(); + SmartDashboard.putData("Field", m_field); + } + + public void driveWithInput(double speedX, double speedY, double rot, boolean fieldRelative) { + Translation2d speed = new Translation2d(speedX, speedY); + driveWithInput(speed, rot, fieldRelative); + } + + /** + * Method to drive the robot using joystick info. + * @link https://github.com/ZachOrr/MK3-Swerve-Example + * @param speeds[0] Speed of the robot in the x direction (forward). + * @param speeds[1] Speed of the robot in the y direction (sideways). + * @param rot Angular rate of the robot. + * @param fieldRelative Whether the provided x and y speeds are relative to the + * field. + */ + public void driveWithInput(Translation2d speed, double rot, boolean fieldRelative) { + ignoreAngles = (speed.getX() == 0) && (speed.getY() == 0) && (rot == 0); + + double mag = speed.getNorm(); + speed = speed.times(mag * speedAdjust); + + double xSpeedMetersPerSecond = speed.getX(); + double ySpeedMetersPerSecond = speed.getY(); + chassisSpeeds = fieldRelative + ? ChassisSpeeds.fromFieldRelativeSpeeds(xSpeedMetersPerSecond, ySpeedMetersPerSecond, + -rot * SwerveDriveConstants.ROTATION_SPEED * 2, new Rotation2d(-m_gyro.getRotation2d().getRadians() + (Math.PI*2) + (Math.PI /2))) + : new ChassisSpeeds(ySpeedMetersPerSecond, -xSpeedMetersPerSecond, + -rot * SwerveDriveConstants.ROTATION_SPEED * 2); + SwerveModuleState[] states = m_kinematics.toSwerveModuleStates(chassisSpeeds); + setModuleStates(states); + } + + public void driveWithInput(double leftX, double leftY, double rightX, double rightY, boolean fieldRelative) { + Translation2d speed = new Translation2d(leftX, leftY); + Translation2d head = new Translation2d(rightX, rightY); + driveWithInput(speed, head, fieldRelative); + } + + // new Rotation2d((360 - m_gyro.getRotation2d().getDegrees() + 90) * (Math.PI/180))) + public void driveWithInput(Translation2d leftStick, Translation2d rightStick, boolean fieldRelative) { + ignoreAngles = leftStick.getX() == 0 && leftStick.getY() == 0 && rightStick.getX() == 0 && rightStick.getY() == 0; + leftStick = leftStick.times(leftStick.getNorm() * speedAdjust); + if (Math.abs(rightStick.getX()) > OIConstants.RIGHT_AXIS_DEADBAND || Math.abs(rightStick.getY()) > OIConstants.RIGHT_AXIS_DEADBAND) + rotTarget = new Rotation2d(rightStick.getX(), -rightStick.getY()).minus(new Rotation2d(0,1)); + double rot = rotTarget.minus(m_gyro.getRotation2d()).getRadians(); + if (ignoreAngles) { + rot = 0; + } + double xSpeedMetersPerSecond = leftStick.getX(); + double ySpeedMetersPerSecond = leftStick.getY(); + chassisSpeeds = fieldRelative + ? ChassisSpeeds.fromFieldRelativeSpeeds(xSpeedMetersPerSecond, ySpeedMetersPerSecond, + rot * SwerveDriveConstants.ROTATION_SPEED * 2, new Rotation2d(-m_gyro.getRotation2d().getRadians() + (Math.PI*2) + (Math.PI /2))) + : new ChassisSpeeds(xSpeedMetersPerSecond, ySpeedMetersPerSecond, rightStick.getX() * SwerveDriveConstants.ROTATION_SPEED * 2); + SwerveModuleState[] states = m_kinematics.toSwerveModuleStates( + chassisSpeeds); + // if (ignoreAngles) { + // SwerveModuleState[] lockedStates = new SwerveModuleState[states.length]; + // for (int i = 0; i < states.length; i ++) { + // SwerveModuleState state = states[i]; + // lockedStates[i]= new SwerveModuleState(0, state.angle); + // } + // setModuleStates(lockedStates); + // } + setModuleStates(states); + // SmartDashboard.putNumber("rot", rot); + // SmartDashboard.putNumber("rotarget", rotTarget.getDegrees()); + } + + /** + * Set each module of the swerve drive to the corresponding desired state. + * + * @param desiredStates Array of module states to set. + */ + public void setModuleStates(SwerveModuleState[] desiredStates) { + SwerveDriveKinematics.desaturateWheelSpeeds(desiredStates, + Units.feetToMeters(SwerveDriveConstants.MAX_SPEED_FEET_PER_SEC)); + // int i = 2; { + for (int i = 0; i < desiredStates.length; i++) { + SwerveModule module = modules[i]; + SwerveModuleState state = desiredStates[i]; + module.setDesiredState(state, ignoreAngles); + } + // modules[0].setDesiredState(desiredStates[0], false); + } + + public void setModuleRotationsToAngle(double angle) { + for (int i = 0; i < modules.length; i++) { + SwerveModule module = modules[i]; + module.rotateToAngle(angle); + } + } + + @Override + public void periodic() { + updateOdometry(); + updateSmartDash(); + + // SmartDashboard.putNumber("Pigeon getRotation2d", m_gyro.getRotation2d().getDegrees()); + // SmartDashboard.putNumber("Pigeon getAngle", m_gyro.getAngle()); + // SmartDashboard.putNumber("Pigeon Yaw", m_gyro.getYaw()); + // SmartDashboard.putNumber("Pigeon Yaw (0 to 360)", m_gyro.getYaw() % 360); + + m_field.setRobotPose(getOdometry()); + super.periodic(); + } + + private void updateSmartDash() { + // odometry + SmartDashboard.putNumber("Odometry: X", getOdometry().getX()); + SmartDashboard.putNumber("Odometry: Y", getOdometry().getY()); + SmartDashboard.putNumber("Odometry: Theta", getOdometry().getRotation().getDegrees()); + + // chassis speeds + // TODO: find the actual max velocity in m/s of the robot in fast mode to have accurate chassis speeds + // SmartDashboard.putNumber("Chassis Vel: X", chassisSpeeds.vxMetersPerSecond); + // SmartDashboard.putNumber("Chassis Vel: Y", chassisSpeeds.vyMetersPerSecond); + // SmartDashboard.putNumber("Chassis Vel: ω", chassisSpeeds.omegaRadiansPerSecond); + } + + /** + * Gets the current chassis speeds in m/s and rad/s. + * @return Current chassis speeds (vx, vy, ω) + */ + public ChassisSpeeds getChassisSpeeds() { + return chassisSpeeds; + } + + /** + * Gets the current pose of the robot. + * + * @return Robot's current pose. + */ + public Pose2d getOdometry() { + // return m_odometry.getPoseMeters(); + return m_odometry.getPoseMeters(); + // return m_poseEstimator.getEstimatedPosition(); + } + + public Pose2d getAutoOdo() { + Pose2d workingPose = getOdometry(); + return new Pose2d(-workingPose.getX(), workingPose.getY(), workingPose.getRotation()); + } + + /** + * Gets the current gyro using regression formula. + * + * @return Rotation2d object holding current gyro in radians + */ + public Rotation2d getRegGyro() { + // * test chassis regression + // double regCur = 0.6552670369 + m_gyro.getRotation2d().getDegrees() * 0.9926871527; + // * new robot regression + double regCur = 0.2507023948 + m_gyro.getRotation2d().getDegrees() * 0.999034743; + return new Rotation2d(Math.toRadians(regCur)); + } + + /** + * Resets the odometry of the robot to the given pose. + */ + public void resetOdometry(Pose2d pose) { + m_odometry.resetPosition(pose, m_gyro.getRotation2d()); + } + + /** + * Updates the field relative position of the robot. + */ + public void updateOdometry() { + Rotation2d actualDWI = new Rotation2d(-m_gyro.getRotation2d().getRadians() + (Math.PI*2)); //+ (Math.PI/2)); + Rotation2d actual = new Rotation2d(m_gyro.getRotation2d().getRadians()); + + SmartDashboard.putNumber("AUTO ACTUAL GYRO", actual.getDegrees()); + SmartDashboard.putNumber("AUTO DWI GYRO", actual.getDegrees()); + + m_odometry.update( actual,//m_gyro.getRotation2d(),//new Rotation2d((2 * Math.PI) - getRegGyro().getRadians()), + modules[0].getState(), + modules[1].getState(), + modules[2].getState(), + modules[3].getState()); + } + + + /** + * Resets pigeon. + */ + public void resetGyro() { + m_gyro.reset(); + rotTarget = new Rotation2d(0); + } + + /** + * Stop all four swerve modules. + */ + public void stopModules() { + modules[0].stop(); + modules[1].stop(); + modules[2].stop(); + modules[3].stop(); + } + + /** + * Switches speed modes. + * + * @param shift True if fast mode, false if slow mode. + */ + public void highSpeed(boolean shift) { + if (shift) { + speedAdjust = SwerveDriveConstants.JOYSTICK_TO_METERS_PER_SECOND_FAST; + } else { + speedAdjust = SwerveDriveConstants.JOYSTICK_TO_METERS_PER_SECOND_SLOW; + } + } + + public double getCurrent(){ + return m_leftFront.getCurrent() + m_rightFront.getCurrent() + m_rightBack.getCurrent() + m_leftBack.getCurrent(); + } + + public double getVoltage(){ + return m_leftFront.getVoltage() + m_rightFront.getVoltage() + m_rightBack.getVoltage() + m_leftBack.getVoltage(); + } +} \ No newline at end of file diff --git a/src/main/java/frc4388/robot/subsystems/SwerveModule.java b/src/main/java/frc4388/robot/subsystems/SwerveModule.java new file mode 100644 index 0000000..68c383d --- /dev/null +++ b/src/main/java/frc4388/robot/subsystems/SwerveModule.java @@ -0,0 +1,181 @@ +// 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 frc4388.robot.subsystems; + +import com.ctre.phoenix.motorcontrol.FeedbackDevice; +import com.ctre.phoenix.motorcontrol.RemoteSensorSource; +import com.ctre.phoenix.motorcontrol.TalonFXControlMode; +import com.ctre.phoenix.motorcontrol.TalonFXFeedbackDevice; +import com.ctre.phoenix.motorcontrol.can.TalonFXConfiguration; +import com.ctre.phoenix.motorcontrol.can.WPI_TalonFX; +import com.ctre.phoenix.sensors.CANCoder; +import com.ctre.phoenix.sensors.CANCoderConfiguration; + +import edu.wpi.first.math.geometry.Rotation2d; +import edu.wpi.first.math.kinematics.SwerveModuleState; +import edu.wpi.first.math.util.Units; +import edu.wpi.first.wpilibj.smartdashboard.SmartDashboard; +import edu.wpi.first.wpilibj2.command.SubsystemBase; +import frc4388.robot.Constants.SwerveDriveConstants; +import frc4388.utility.Gains; + +public class SwerveModule extends SubsystemBase { + public WPI_TalonFX angleMotor; + public WPI_TalonFX driveMotor; + private CANCoder canCoder; + public static Gains m_swerveGains = SwerveDriveConstants.SWERVE_GAINS; + + private static double kEncoderTicksPerRotation = 4096; + private SwerveModuleState state; + private double canCoderFeedbackCoefficient; + + public long m_currentTime; + public long m_lastTime; + public double m_deltaTime; + + public double m_currentPos; + public double m_lastPos; + + public SwerveModuleState lastState = new SwerveModuleState(); + public SwerveModuleState currentState; + + /** Creates a new SwerveModule. */ + public SwerveModule(WPI_TalonFX driveMotor, WPI_TalonFX angleMotor, CANCoder canCoder, double offset) { + this.driveMotor = driveMotor; + this.angleMotor = angleMotor; + this.canCoder = canCoder; + canCoderFeedbackCoefficient = canCoder.configGetFeedbackCoefficient(); + + TalonFXConfiguration angleTalonFXConfiguration = new TalonFXConfiguration(); + + angleTalonFXConfiguration.slot0.kP = m_swerveGains.kP; + angleTalonFXConfiguration.slot0.kI = m_swerveGains.kI; + angleTalonFXConfiguration.slot0.kD = m_swerveGains.kD; + + // Use the CANCoder as the remote sensor for the primary TalonFX PID + angleTalonFXConfiguration.remoteFilter0.remoteSensorDeviceID = canCoder.getDeviceID(); + angleTalonFXConfiguration.remoteFilter0.remoteSensorSource = RemoteSensorSource.CANCoder; + angleTalonFXConfiguration.primaryPID.selectedFeedbackSensor = FeedbackDevice.RemoteSensor0; + angleMotor.configAllSettings(angleTalonFXConfiguration); + // angleMotor.setInverted(true); + // TalonFXConfiguration driveTalonFXConfiguration = new TalonFXConfiguration(); + // driveTalonFXConfiguration.slot0.kP = 0.05; + // driveTalonFXConfiguration.slot0.kI = 0.0; + // driveTalonFXConfiguration.slot0.kD = 0.0; + // driveTalonFXConfiguration.primaryPID.selectedFeedbackSensor = + // FeedbackDevice.IntegratedSensor; + driveMotor.configFactoryDefault(); + driveMotor.configSelectedFeedbackSensor(TalonFXFeedbackDevice.IntegratedSensor, 0, 30); + driveMotor.configNominalOutputForward(0, 30); + driveMotor.configNominalOutputReverse(0, 30); + driveMotor.configPeakOutputForward(1, 30); + driveMotor.configPeakOutputReverse(-1, 30); + driveMotor.configAllowableClosedloopError(0, 0, 30); + // driveMotor.setInverted(true); + driveMotor.config_kP(0, 0, 30); + driveMotor.config_kI(0, 0, 30); + driveMotor.config_kD(0, 0, 30); + + // driveMotor.configAllSettings(driveTalonFXConfiguration); + + CANCoderConfiguration canCoderConfiguration = new CANCoderConfiguration(); + canCoderConfiguration.sensorCoefficient = 0.087890625; + canCoderConfiguration.magnetOffsetDegrees = offset; + canCoderConfiguration.sensorDirection = true; + canCoder.configAllSettings(canCoderConfiguration); + + m_currentTime = System.currentTimeMillis(); + m_lastTime = System.currentTimeMillis(); + + m_lastPos = driveMotor.getSelectedSensorPosition(); + } + + private Rotation2d getAngle() { + // ! Note: This assumes the CANCoders are setup with the default feedback coefficient and the sensor value reports degrees. + return Rotation2d.fromDegrees(canCoder.getAbsolutePosition()); + } + + /** + * Set the speed + rotation of the swerve module from a SwerveModuleState object + * + * @param desiredState - A SwerveModuleState representing the desired new state + * of the module + */ + public void setDesiredState(SwerveModuleState desiredState, boolean ignoreAngle) { + Rotation2d currentRotation = getAngle(); + // currentRotation.getDegrees()); + state = SwerveModuleState.optimize(desiredState, currentRotation); + + // Find the difference between our current rotational position + our new + // rotational position + Rotation2d rotationDelta = state.angle.minus(currentRotation); + + // Find the new absolute position of the module based on the difference in + // rotation + double deltaTicks = (rotationDelta.getDegrees() / 360.) * kEncoderTicksPerRotation; + // Convert the CANCoder from it's position reading back to ticks + double currentTicks = canCoder.getPosition() / canCoderFeedbackCoefficient; + double desiredTicks = currentTicks + deltaTicks; + + if (!ignoreAngle) { + angleMotor.set(TalonFXControlMode.Position, desiredTicks); + } + + // Please work + double ftPerSec = Units.metersToFeet(state.speedMetersPerSecond); + double normFtPerSec = ftPerSec / SwerveDriveConstants.MAX_SPEED_FEET_PER_SEC; + // double angleCorrection = angleMotor.getSelectedSensorVelocity() * 2.69; + driveMotor.set(normFtPerSec);// - angleMotor.get()); + // driveMotor.set(TalonFXControlMode.Velocity, angleCorrection); // Ratio + // between axis = 1/1.75 Ratio of wheel is 5.14/1 ratio of steer is 12.8/1 + } + + /** + * Get current module state. + * + * @return The current state of the module in m/s. + */ + public SwerveModuleState getState() { + // return state; + return new SwerveModuleState(driveMotor.getSelectedSensorVelocity() * SwerveDriveConstants.INCHES_PER_TICK + * SwerveDriveConstants.METERS_PER_INCH * 10, getAngle()); + } + + /** + * Stop the drive and steer motors of current module. + */ + public void stop() { + driveMotor.set(0); + angleMotor.set(0); + } + + public void rotateToAngle(double angle) { + this.angleMotor.set(TalonFXControlMode.Position, angle); + } + + @Override + public void periodic() { + currentState = this.getState(); + + Rotation2d currentRotation = getAngle(); + SmartDashboard.putNumber("Angle Motor " + angleMotor.getDeviceID(), currentRotation.getDegrees()); + SmartDashboard.putNumber("Drive Motor " + driveMotor.getDeviceID(), + ((driveMotor.getSelectedSensorPosition() / 2048) * 360) % 360); + + lastState = currentState; + } + + public void reset() { + canCoder.setPositionToAbsolute(); + // canCoder.configSensorInitializationStrategy(initializationStrategy) + } + public double getCurrent(){ + return angleMotor.getSupplyCurrent() + driveMotor.getSupplyCurrent(); + } + + public double getVoltage(){ + return (Math.abs(angleMotor.getMotorOutputVoltage()) + Math.abs(driveMotor.getMotorOutputVoltage())); + } +} \ No newline at end of file From 82b9a2eaca1f18f67d54912982fb70b16a9c7477 Mon Sep 17 00:00:00 2001 From: 66945 <54561572+66945@users.noreply.github.com> Date: Tue, 1 Nov 2022 17:48:59 -0600 Subject: [PATCH 2/4] Update Constants.java --- src/main/java/frc4388/robot/Constants.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/main/java/frc4388/robot/Constants.java b/src/main/java/frc4388/robot/Constants.java index 84bd57a..ee88284 100644 --- a/src/main/java/frc4388/robot/Constants.java +++ b/src/main/java/frc4388/robot/Constants.java @@ -8,6 +8,7 @@ package frc4388.robot; import frc4388.utility.LEDPatterns; +import frc4388.utility.Gains; /** * The Constants class provides a convenient place for teams to hold robot-wide numerical or boolean From 5b2e8f7e98501399fb33fb176e72bb98e529c5ab Mon Sep 17 00:00:00 2001 From: Abhishrek05 <90010729+Abhishrek05@users.noreply.github.com> Date: Fri, 5 Jan 2024 13:56:01 -0700 Subject: [PATCH 3/4] worky --- .gitignore | 17 +- .vscode/settings.json | 18 +- .wpilib/wpilib_preferences.json | 2 +- WPILib-License.md | 24 ++ build.gradle | 94 +++-- gradle/wrapper/gradle-wrapper.jar | Bin 58702 -> 60756 bytes gradle/wrapper/gradle-wrapper.properties | 2 +- gradlew | 275 +++++++----- gradlew.bat | 37 +- settings.gradle | 2 +- src/main/java/frc4388/robot/Constants.java | 136 ++++-- src/main/java/frc4388/robot/RobotMap.java | 2 +- .../frc4388/robot/subsystems/DiffDrive.java | 2 +- .../java/frc4388/robot/subsystems/LED.java | 2 +- .../frc4388/robot/subsystems/SwerveDrive.java | 396 ++++++----------- .../robot/subsystems/SwerveModule.java | 228 +++++----- src/main/java/frc4388/utility/Gains.java | 83 ++++ src/main/java/frc4388/utility/RobotGyro.java | 44 +- .../utility/controller/XboxTriggerButton.java | 3 +- .../robot/subsystems/LEDSubsystemTest.old | 59 +++ .../frc4388/utility/RobotGyroUtilityTest.old | 184 ++++++++ .../frc4388/utility/RobotTimeUtilityTest.old | 104 +++++ vendordeps/NavX.json | 39 ++ vendordeps/Phoenix.json | 397 ++++++++++++++---- vendordeps/WPILibNewCommands.json | 72 ++-- 25 files changed, 1493 insertions(+), 729 deletions(-) create mode 100644 WPILib-License.md create mode 100644 src/main/java/frc4388/utility/Gains.java create mode 100644 src/test/java/frc4388/robot/subsystems/LEDSubsystemTest.old create mode 100644 src/test/java/frc4388/utility/RobotGyroUtilityTest.old create mode 100644 src/test/java/frc4388/utility/RobotTimeUtilityTest.old create mode 100644 vendordeps/NavX.json diff --git a/.gitignore b/.gitignore index 983678a..a8d1911 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,5 @@ -# Created by https://www.gitignore.io/api/c++,java,linux,macos,gradle,windows,visualstudiocode +# This gitignore has been specially created by the WPILib team. +# If you remove items from this file, intellisense might break. ### C++ ### # Prerequisites @@ -151,11 +152,21 @@ gradle-app.setting # gradle/wrapper/gradle-wrapper.properties # # VS Code Specific Java Settings +# DO NOT REMOVE .classpath and .project .classpath .project .settings/ bin/ -imgui.ini +# IntelliJ +*.iml +*.ipr +*.iws +.idea/ +out/ -# End of https://www.gitignore.io/api/c++,java,linux,macos,gradle,windows,visualstudiocode +# Fleet +.fleet + +# Simulation GUI and other tools window save file +*-window.json diff --git a/.vscode/settings.json b/.vscode/settings.json index 5200b5c..4ed293b 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,5 +1,6 @@ { "java.configuration.updateBuildConfiguration": "automatic", + "java.server.launchMode": "Standard", "files.exclude": { "**/.git": true, "**/.svn": true, @@ -10,6 +11,19 @@ "**/.classpath": true, "**/.project": true, "**/.settings": true, - "**/.factorypath": true - } + "**/.factorypath": true, + "**/*~": true + }, + "java.test.config": [ + { + "name": "WPIlibUnitTests", + "workingDirectory": "${workspaceFolder}/build/jni/release", + "vmargs": [ "-Djava.library.path=${workspaceFolder}/build/jni/release" ], + "env": { + "LD_LIBRARY_PATH": "${workspaceFolder}/build/jni/release" , + "DYLD_LIBRARY_PATH": "${workspaceFolder}/build/jni/release" + } + }, + ], + "java.test.defaultConfig": "WPIlibUnitTests" } diff --git a/.wpilib/wpilib_preferences.json b/.wpilib/wpilib_preferences.json index a5920a4..9c62ece 100644 --- a/.wpilib/wpilib_preferences.json +++ b/.wpilib/wpilib_preferences.json @@ -1,6 +1,6 @@ { "enableCppIntellisense": false, "currentLanguage": "java", - "projectYear": "2020", + "projectYear": "2023", "teamNumber": 4388 } \ No newline at end of file diff --git a/WPILib-License.md b/WPILib-License.md new file mode 100644 index 0000000..3d5a824 --- /dev/null +++ b/WPILib-License.md @@ -0,0 +1,24 @@ +Copyright (c) 2009-2021 FIRST and other WPILib contributors +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of FIRST, WPILib, nor the names of other WPILib + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY FIRST AND OTHER WPILIB CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY NONINFRINGEMENT AND FITNESS FOR A PARTICULAR +PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL FIRST OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/build.gradle b/build.gradle index b202c6b..a2aa528 100644 --- a/build.gradle +++ b/build.gradle @@ -1,6 +1,6 @@ plugins { id "java" - id "edu.wpi.first.GradleRIO" version "2020.3.2" + id "edu.wpi.first.GradleRIO" version "2023.4.3" } sourceCompatibility = JavaVersion.VERSION_11 @@ -9,61 +9,91 @@ targetCompatibility = JavaVersion.VERSION_11 def ROBOT_MAIN_CLASS = "frc4388.robot.Main" // Define my targets (RoboRIO) and artifacts (deployable files) -// This is added by GradleRIO's backing project EmbeddedTools. +// This is added by GradleRIO's backing project DeployUtils. deploy { targets { - roboRIO("roborio") { + roborio(getTargetTypeClass('RoboRIO')) { // Team number is loaded either from the .wpilib/wpilib_preferences.json // or from command line. If not found an exception will be thrown. // You can use getTeamOrDefault(team) instead of getTeamNumber if you // want to store a team number in this file. - team = frc.getTeamNumber() - } - } - artifacts { - frcJavaArtifact('frcJava') { - targets << "roborio" - // Debug can be overridden by command line, for use with VSCode - debug = frc.getDebugOrDefault(false) - } - // Built in artifact to deploy arbitrary files to the roboRIO. - fileTreeArtifact('frcStaticFileDeploy') { - // The directory below is the local directory to deploy - files = fileTree(dir: 'src/main/deploy') - // Deploy to RoboRIO target, into /home/lvuser/deploy - targets << "roborio" - directory = '/home/lvuser/deploy' + team = project.frc.getTeamNumber() + debug = project.frc.getDebugOrDefault(false) + + artifacts { + // First part is artifact name, 2nd is artifact type + // getTargetTypeClass is a shortcut to get the class type using a string + + frcJava(getArtifactTypeClass('FRCJavaArtifact')) { + } + + // Static files artifact + frcStaticFileDeploy(getArtifactTypeClass('FileTreeArtifact')) { + files = project.fileTree('src/main/deploy') + directory = '/home/lvuser/deploy' + } + } } } } +def deployArtifact = deploy.targets.roborio.artifacts.frcJava + +// Set to true to use debug for JNI. +wpi.java.debugJni = false + // Set this to true to enable desktop support. -def includeDesktopSupport = true +def includeDesktopSupport = false // Defining my dependencies. In this case, WPILib (+ friends), and vendor libraries. -// Also defines JUnit 4. +// Also defines JUnit 5. dependencies { - implementation wpi.deps.wpilib() - nativeZip wpi.deps.wpilibJni(wpi.platforms.roborio) - nativeDesktopZip wpi.deps.wpilibJni(wpi.platforms.desktop) + implementation wpi.java.deps.wpilib() + implementation wpi.java.vendor.java() + roborioDebug wpi.java.deps.wpilibJniDebug(wpi.platforms.roborio) + roborioDebug wpi.java.vendor.jniDebug(wpi.platforms.roborio) - implementation wpi.deps.vendor.java() - nativeZip wpi.deps.vendor.jni(wpi.platforms.roborio) - nativeDesktopZip wpi.deps.vendor.jni(wpi.platforms.desktop) + roborioRelease wpi.java.deps.wpilibJniRelease(wpi.platforms.roborio) + roborioRelease wpi.java.vendor.jniRelease(wpi.platforms.roborio) - testImplementation 'junit:junit:4.12' - testCompile "org.mockito:mockito-core:2.+" + nativeDebug wpi.java.deps.wpilibJniDebug(wpi.platforms.desktop) + nativeDebug wpi.java.vendor.jniDebug(wpi.platforms.desktop) + simulationDebug wpi.sim.enableDebug() - // Enable simulation gui support. Must check the box in vscode to enable support - // upon debugging - simulation wpi.deps.sim.gui(wpi.platforms.desktop, false) + nativeRelease wpi.java.deps.wpilibJniRelease(wpi.platforms.desktop) + nativeRelease wpi.java.vendor.jniRelease(wpi.platforms.desktop) + simulationRelease wpi.sim.enableRelease() + + testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.2' + testImplementation 'org.junit.jupiter:junit-jupiter-params:5.8.2' + testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.2' } +test { + useJUnitPlatform() + systemProperty 'junit.jupiter.extensions.autodetection.enabled', 'true' +} + +// Simulation configuration (e.g. environment variables). +wpi.sim.addGui().defaultEnabled = true +wpi.sim.addDriverstation() + // Setting up my Jar File. In this case, adding all libraries into the main jar ('fat jar') // in order to make them all available at runtime. Also adding the manifest so WPILib // knows where to look for our Robot Class. jar { from { configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) } } manifest edu.wpi.first.gradlerio.GradleRIOPlugin.javaManifest(ROBOT_MAIN_CLASS) + duplicatesStrategy = DuplicatesStrategy.INCLUDE +} + +// Configure jar and deploy tasks +deployArtifact.jarTask = jar +wpi.java.configureExecutableTasks(jar) +wpi.java.configureTestTasks(test) + +// Configure string concat to always inline compile +tasks.withType(JavaCompile) { + options.compilerArgs.add '-XDstringConcat=inline' } diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar index cc4fdc293d0e50b0ad9b65c16e7ddd1db2f6025b..249e5832f090a2944b7473328c07c9755baa3196 100644 GIT binary patch delta 25742 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 delta 23617 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 diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index d050f17..c23a1b3 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,5 +1,5 @@ distributionBase=GRADLE_USER_HOME distributionPath=permwrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-6.0.1-bin.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-bin.zip zipStoreBase=GRADLE_USER_HOME zipStorePath=permwrapper/dists diff --git a/gradlew b/gradlew index 2fe81a7..a69d9cb 100644 --- a/gradlew +++ b/gradlew @@ -1,7 +1,7 @@ -#!/usr/bin/env sh +#!/bin/sh # -# Copyright 2015 the original author or authors. +# Copyright © 2015-2021 the original authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -17,78 +17,113 @@ # ############################################################################## -## -## Gradle start up script for UN*X -## +# +# Gradle start up script for POSIX generated by Gradle. +# +# Important for running: +# +# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is +# noncompliant, but you have some other compliant shell such as ksh or +# bash, then to run this script, type that shell name before the whole +# command line, like: +# +# ksh Gradle +# +# Busybox and similar reduced shells will NOT work, because this script +# requires all of these POSIX shell features: +# * functions; +# * expansions «$var», «${var}», «${var:-default}», «${var+SET}», +# «${var#prefix}», «${var%suffix}», and «$( cmd )»; +# * compound commands having a testable exit status, especially «case»; +# * various built-in commands including «command», «set», and «ulimit». +# +# Important for patching: +# +# (2) This script targets any POSIX shell, so it avoids extensions provided +# by Bash, Ksh, etc; in particular arrays are avoided. +# +# The "traditional" practice of packing multiple parameters into a +# space-separated string is a well documented source of bugs and security +# problems, so this is (mostly) avoided, by progressively accumulating +# options in "$@", and eventually passing that to Java. +# +# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, +# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; +# see the in-line comments for details. +# +# There are tweaks for specific operating systems such as AIX, CygWin, +# Darwin, MinGW, and NonStop. +# +# (3) This script is generated from the Groovy template +# https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# within the Gradle project. +# +# You can find Gradle at https://github.com/gradle/gradle/. +# ############################################################################## # Attempt to set APP_HOME + # Resolve links: $0 may be a link -PRG="$0" -# Need this for relative symlinks. -while [ -h "$PRG" ] ; do - ls=`ls -ld "$PRG"` - link=`expr "$ls" : '.*-> \(.*\)$'` - if expr "$link" : '/.*' > /dev/null; then - PRG="$link" - else - PRG=`dirname "$PRG"`"/$link" - fi +app_path=$0 + +# Need this for daisy-chained symlinks. +while + APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path + [ -h "$app_path" ] +do + ls=$( ls -ld "$app_path" ) + link=${ls#*' -> '} + case $link in #( + /*) app_path=$link ;; #( + *) app_path=$APP_HOME$link ;; + esac done -SAVED="`pwd`" -cd "`dirname \"$PRG\"`/" >/dev/null -APP_HOME="`pwd -P`" -cd "$SAVED" >/dev/null + +APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit APP_NAME="Gradle" -APP_BASE_NAME=`basename "$0"` +APP_BASE_NAME=${0##*/} # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' # Use the maximum available, or set MAX_FD != -1 to use that value. -MAX_FD="maximum" +MAX_FD=maximum warn () { echo "$*" -} +} >&2 die () { echo echo "$*" echo exit 1 -} +} >&2 # OS specific support (must be 'true' or 'false'). cygwin=false msys=false darwin=false nonstop=false -case "`uname`" in - CYGWIN* ) - cygwin=true - ;; - Darwin* ) - darwin=true - ;; - MINGW* ) - msys=true - ;; - NONSTOP* ) - nonstop=true - ;; +case "$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; esac CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + # Determine the Java command to use to start the JVM. if [ -n "$JAVA_HOME" ] ; then if [ -x "$JAVA_HOME/jre/sh/java" ] ; then # IBM's JDK on AIX uses strange locations for the executables - JAVACMD="$JAVA_HOME/jre/sh/java" + JAVACMD=$JAVA_HOME/jre/sh/java else - JAVACMD="$JAVA_HOME/bin/java" + JAVACMD=$JAVA_HOME/bin/java fi if [ ! -x "$JAVACMD" ] ; then die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME @@ -97,7 +132,7 @@ Please set the JAVA_HOME variable in your environment to match the location of your Java installation." fi else - JAVACMD="java" + JAVACMD=java which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. Please set the JAVA_HOME variable in your environment to match the @@ -105,79 +140,101 @@ location of your Java installation." fi # Increase the maximum file descriptors if we can. -if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then - MAX_FD_LIMIT=`ulimit -H -n` - if [ $? -eq 0 ] ; then - if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then - MAX_FD="$MAX_FD_LIMIT" - fi - ulimit -n $MAX_FD - if [ $? -ne 0 ] ; then - warn "Could not set maximum file descriptor limit: $MAX_FD" - fi - else - warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" - fi -fi - -# For Darwin, add options to specify how the application appears in the dock -if $darwin; then - GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" -fi - -# For Cygwin or MSYS, switch paths to Windows format before running java -if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then - APP_HOME=`cygpath --path --mixed "$APP_HOME"` - CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` - JAVACMD=`cygpath --unix "$JAVACMD"` - - # We build the pattern for arguments to be converted via cygpath - ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` - SEP="" - for dir in $ROOTDIRSRAW ; do - ROOTDIRS="$ROOTDIRS$SEP$dir" - SEP="|" - done - OURCYGPATTERN="(^($ROOTDIRS))" - # Add a user-defined pattern to the cygpath arguments - if [ "$GRADLE_CYGPATTERN" != "" ] ; then - OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" - fi - # Now convert the arguments - kludge to limit ourselves to /bin/sh - i=0 - for arg in "$@" ; do - CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` - CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option - - if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition - eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` - else - eval `echo args$i`="\"$arg\"" - fi - i=`expr $i + 1` - done - case $i in - 0) set -- ;; - 1) set -- "$args0" ;; - 2) set -- "$args0" "$args1" ;; - 3) set -- "$args0" "$args1" "$args2" ;; - 4) set -- "$args0" "$args1" "$args2" "$args3" ;; - 5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; - 6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; - 7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; - 8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; - 9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then + case $MAX_FD in #( + max*) + MAX_FD=$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case $MAX_FD in #( + '' | soft) :;; #( + *) + ulimit -n "$MAX_FD" || + warn "Could not set maximum file descriptor limit to $MAX_FD" esac fi -# Escape application args -save () { - for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done - echo " " -} -APP_ARGS=`save "$@"` +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. -# Collect all arguments for the java command, following the shell quoting and substitution rules -eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then + APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" ) + + JAVACMD=$( cygpath --unix "$JAVACMD" ) + + # Now convert the arguments - kludge to limit ourselves to /bin/sh + for arg do + if + case $arg in #( + -*) false ;; # don't mess with options #( + /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + [ -e "$t" ] ;; #( + *) false ;; + esac + then + arg=$( cygpath --path --ignore --mixed "$arg" ) + fi + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "$@" "$arg" # push replacement arg + done +fi + +# Collect all arguments for the java command; +# * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of +# shell script including quotes and variable substitutions, so put them in +# double quotes to make sure that they get re-expanded; and +# * put everything else in single quotes, so that it's not re-expanded. + +set -- \ + "-Dorg.gradle.appname=$APP_BASE_NAME" \ + -classpath "$CLASSPATH" \ + org.gradle.wrapper.GradleWrapperMain \ + "$@" + +# Stop when "xargs" is not available. +if ! command -v xargs >/dev/null 2>&1 +then + die "xargs is not available" +fi + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( + printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | + tr '\n' ' ' + )" '"$@"' exec "$JAVACMD" "$@" diff --git a/gradlew.bat b/gradlew.bat index 9618d8d..f127cfd 100644 --- a/gradlew.bat +++ b/gradlew.bat @@ -14,7 +14,7 @@ @rem limitations under the License. @rem -@if "%DEBUG%" == "" @echo off +@if "%DEBUG%"=="" @echo off @rem ########################################################################## @rem @rem Gradle startup script for Windows @@ -25,10 +25,13 @@ if "%OS%"=="Windows_NT" setlocal set DIRNAME=%~dp0 -if "%DIRNAME%" == "" set DIRNAME=. +if "%DIRNAME%"=="" set DIRNAME=. set APP_BASE_NAME=%~n0 set APP_HOME=%DIRNAME% +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" @@ -37,7 +40,7 @@ if defined JAVA_HOME goto findJavaFromJavaHome set JAVA_EXE=java.exe %JAVA_EXE% -version >NUL 2>&1 -if "%ERRORLEVEL%" == "0" goto init +if %ERRORLEVEL% equ 0 goto execute echo. echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. @@ -51,7 +54,7 @@ goto fail set JAVA_HOME=%JAVA_HOME:"=% set JAVA_EXE=%JAVA_HOME%/bin/java.exe -if exist "%JAVA_EXE%" goto init +if exist "%JAVA_EXE%" goto execute echo. echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% @@ -61,38 +64,26 @@ echo location of your Java installation. goto fail -:init -@rem Get command-line arguments, handling Windows variants - -if not "%OS%" == "Windows_NT" goto win9xME_args - -:win9xME_args -@rem Slurp the command line arguments. -set CMD_LINE_ARGS= -set _SKIP=2 - -:win9xME_args_slurp -if "x%~1" == "x" goto execute - -set CMD_LINE_ARGS=%* - :execute @rem Setup the command line set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + @rem Execute Gradle -"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* :end @rem End local scope for the variables with windows NT shell -if "%ERRORLEVEL%"=="0" goto mainEnd +if %ERRORLEVEL% equ 0 goto mainEnd :fail rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of rem the _cmd.exe /c_ return code! -if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 -exit /b 1 +set EXIT_CODE=%ERRORLEVEL% +if %EXIT_CODE% equ 0 set EXIT_CODE=1 +if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% +exit /b %EXIT_CODE% :mainEnd if "%OS%"=="Windows_NT" endlocal diff --git a/settings.gradle b/settings.gradle index 81f96ab..48c039e 100644 --- a/settings.gradle +++ b/settings.gradle @@ -4,7 +4,7 @@ pluginManagement { repositories { mavenLocal() gradlePluginPortal() - String frcYear = '2020' + String frcYear = '2023' File frcHome if (OperatingSystem.current().isWindows()) { String publicFolder = System.getenv('PUBLIC') diff --git a/src/main/java/frc4388/robot/Constants.java b/src/main/java/frc4388/robot/Constants.java index 0c85eb6..7077079 100644 --- a/src/main/java/frc4388/robot/Constants.java +++ b/src/main/java/frc4388/robot/Constants.java @@ -7,6 +7,8 @@ package frc4388.robot; +import edu.wpi.first.math.trajectory.TrapezoidProfile; + import frc4388.utility.LEDPatterns; import frc4388.utility.Gains; @@ -19,52 +21,96 @@ import frc4388.utility.Gains; * constants are needed, to reduce verbosity. */ public final class Constants { - public static final class SwerveDriveConstants { - public static final double ROTATION_SPEED = 0.1; - public static final double WHEEL_SPEED = 0.1; - public static final double WIDTH = 22; - public static final double HEIGHT = 22; - public static final double JOYSTICK_TO_METERS_PER_SECOND = 5; - public static final double MAX_SPEED_FEET_PER_SEC = 16; - public static final double SPEED_FEET_PER_SECOND_AT_FULL_POWER = 20; - public static final int LEFT_FRONT_STEER_CAN_ID = 2; - public static final int LEFT_FRONT_WHEEL_CAN_ID = 3; - public static final int RIGHT_FRONT_STEER_CAN_ID = 4; - public static final int RIGHT_FRONT_WHEEL_CAN_ID = 5; - public static final int LEFT_BACK_STEER_CAN_ID = 6; - public static final int LEFT_BACK_WHEEL_CAN_ID = 7; - public static final int RIGHT_BACK_STEER_CAN_ID = 8; - public static final int RIGHT_BACK_WHEEL_CAN_ID = 9; - public static final int LEFT_FRONT_STEER_CAN_ENCODER_ID = 10; - public static final int RIGHT_FRONT_STEER_CAN_ENCODER_ID = 11; - public static final int LEFT_BACK_STEER_CAN_ENCODER_ID = 12; - public static final int RIGHT_BACK_STEER_CAN_ENCODER_ID = 13; - // ofsets are in degrees - //ofsets are in degrees - // public static final double LEFT_FRONT_ENCODER_OFFSET = 181.494141; - // public static final double RIGHT_FRONT_ENCODER_OFFSET = 360. - 59.238281; - // public static final double LEFT_BACK_ENCODER_OFFSET = 360. - 128.144531; - // public static final double RIGHT_BACK_ENCODER_OFFSET = 0.933594; - public static final double LEFT_FRONT_ENCODER_OFFSET = 180.0; - public static final double RIGHT_FRONT_ENCODER_OFFSET = 300.0; - public static final double LEFT_BACK_ENCODER_OFFSET = 360.0 - 128.0; - public static final double RIGHT_BACK_ENCODER_OFFSET = 0.0; - - // swerve PID constants - public static final int SWERVE_SLOT_IDX = 0; - public static final int SWERVE_PID_LOOP_IDX = 1; - public static final int SWERVE_TIMEOUT_MS = 30; - public static final Gains SWERVE_GAINS = new Gains(1.0, 0.0, 0.0, 0.0, 0, 1.0); - - // swerve configuration - public static final double NEUTRAL_DEADBAND = 0.04; - public static final double OPEN_LOOP_RAMP_RATE = 0.2; - public static final int REMOTE_0 = 0; - - // misc - public static final int SMARTDASHBOARD_UPDATE_FRAME = 2; - } + public static final class SwerveDriveConstants { + public static final double MAX_ROT_SPEED = 1.5; + public static final double MIN_ROT_SPEED = 0.8; + public static double ROTATION_SPEED = MAX_ROT_SPEED; + public static double ROT_CORRECTION_SPEED = 10; // MIN_ROT_SPEED; + + public static final double CORRECTION_MIN = 10; + public static final double CORRECTION_MAX = 50; + + public static final double SLOW_SPEED = 0.8; + public static final double FAST_SPEED = 1.0; + public static final double TURBO_SPEED = 4.0; + + public static final class IDs { + public static final int LEFT_FRONT_WHEEL_ID = 2; + public static final int LEFT_FRONT_STEER_ID = 3; + public static final int LEFT_FRONT_ENCODER_ID = 10; + + public static final int RIGHT_FRONT_WHEEL_ID = 4; + public static final int RIGHT_FRONT_STEER_ID = 5; + public static final int RIGHT_FRONT_ENCODER_ID = 11; + + public static final int LEFT_BACK_WHEEL_ID = 6; + public static final int LEFT_BACK_STEER_ID = 7; + public static final int LEFT_BACK_ENCODER_ID = 12; + + public static final int RIGHT_BACK_WHEEL_ID = 8; + public static final int RIGHT_BACK_STEER_ID = 9; + public static final int RIGHT_BACK_ENCODER_ID = 13; + } + + public static final class PIDConstants { + public static final int SWERVE_SLOT_IDX = 0; + public static final int SWERVE_PID_LOOP_IDX = 1; + public static final Gains SWERVE_GAINS = new Gains(0.5, 0.0, 0.0, 0.0, 0, 1.0); + } + + public static final class AutoConstants { + public static final Gains X_CONTROLLER = new Gains(0.8, 0.0, 0.0); + public static final Gains Y_CONTROLLER = new Gains(0.8, 0.0, 0.0); + public static final Gains THETA_CONTROLLER = new Gains(-0.8, 0.0, 0.0); + public static final TrapezoidProfile.Constraints THETA_CONSTRAINTS = new TrapezoidProfile.Constraints(Math.PI/2, Math.PI/2); // TODO: tune + + public static final double PATH_MAX_VEL = 0.3; // TODO: find the actual value + public static final double PATH_MAX_ACC = 0.3; // TODO: find the actual value + } + + public static final class Conversions { + public static final int CANCODER_TICKS_PER_ROTATION = 4096; + + public static final double JOYSTICK_TO_METERS_PER_SECOND_FAST = 4.8; + public static final double JOYSTICK_TO_METERS_PER_SECOND_SLOW = 0.8; + + public static final double MOTOR_REV_PER_WHEEL_REV = 5.12; + public static final double MOTOR_REV_PER_STEER_REV = 12.8; + + public static final double TICKS_PER_MOTOR_REV = 2048; + public static final double WHEEL_DIAMETER_INCHES = 3.9; + public static final double INCHES_PER_WHEEL_REV = WHEEL_DIAMETER_INCHES * Math.PI; + + public static final double WHEEL_REV_PER_MOTOR_REV = 1 / MOTOR_REV_PER_WHEEL_REV; + public static final double TICKS_PER_WHEEL_REV = TICKS_PER_MOTOR_REV * MOTOR_REV_PER_WHEEL_REV; + public static final double TICKS_PER_INCH = TICKS_PER_WHEEL_REV / INCHES_PER_WHEEL_REV; + public static final double INCHES_PER_TICK = 1 / TICKS_PER_INCH; + + public static final double TICK_TIME_TO_SECONDS = 10; + public static final double SECONDS_TO_TICK_TIME = 1 / TICK_TIME_TO_SECONDS; + } + + public static final class Configurations { + public static final double OPEN_LOOP_RAMP_RATE = 0.2; // TODO: find the actual value + public static final double CLOSED_LOOP_RAMP_RATE = 0.2; // TODO: find the actual value + public static final double NEUTRAL_DEADBAND = 0.04; // TODO: find the actual value + } + + public static final double MAX_SPEED_FEET_PER_SECOND = 5; // TODO: find the actual value + public static final double MAX_ANGULAR_SPEED_FEET_PER_SECOND = 2 * 2 * Math.PI; // TODO: find the actual value + + // dimensions + public static final double WIDTH = 18.5; + public static final double HEIGHT = 18.5; + public static final double HALF_WIDTH = WIDTH / 2.d; + public static final double HALF_HEIGHT = HEIGHT / 2.d; + + // misc + public static final int TIMEOUT_MS = 30; + public static final int SMARTDASHBOARD_UPDATE_FRAME = 2; + } + public static final class DriveConstants { public static final int DRIVE_PIGEON_ID = 6; diff --git a/src/main/java/frc4388/robot/RobotMap.java b/src/main/java/frc4388/robot/RobotMap.java index 4bec615..5f17853 100644 --- a/src/main/java/frc4388/robot/RobotMap.java +++ b/src/main/java/frc4388/robot/RobotMap.java @@ -12,7 +12,7 @@ import com.ctre.phoenix.motorcontrol.NeutralMode; import com.ctre.phoenix.motorcontrol.can.WPI_TalonFX; import com.ctre.phoenix.sensors.PigeonIMU; -import edu.wpi.first.wpilibj.Spark; +import edu.wpi.first.wpilibj.motorcontrol.Spark; import edu.wpi.first.wpilibj.drive.DifferentialDrive; import frc4388.robot.Constants.LEDConstants; import frc4388.utility.RobotGyro; diff --git a/src/main/java/frc4388/robot/subsystems/DiffDrive.java b/src/main/java/frc4388/robot/subsystems/DiffDrive.java index a791913..9ec39df 100644 --- a/src/main/java/frc4388/robot/subsystems/DiffDrive.java +++ b/src/main/java/frc4388/robot/subsystems/DiffDrive.java @@ -80,6 +80,6 @@ public class DiffDrive extends SubsystemBase { SmartDashboard.putBoolean("Is Gyro a Pigeon?", m_gyro.m_isGyroAPigeon); SmartDashboard.putNumber("Turn Rate", m_gyro.getRate()); SmartDashboard.putNumber("Gyro Pitch", m_gyro.getPitch()); - SmartDashboard.putData(m_gyro); + //SmartDashboard.putData(m_gyro); } } diff --git a/src/main/java/frc4388/robot/subsystems/LED.java b/src/main/java/frc4388/robot/subsystems/LED.java index 57c7b58..0d4af80 100644 --- a/src/main/java/frc4388/robot/subsystems/LED.java +++ b/src/main/java/frc4388/robot/subsystems/LED.java @@ -7,7 +7,7 @@ package frc4388.robot.subsystems; -import edu.wpi.first.wpilibj.Spark; +import edu.wpi.first.wpilibj.motorcontrol.Spark; import edu.wpi.first.wpilibj.smartdashboard.SmartDashboard; import edu.wpi.first.wpilibj2.command.SubsystemBase; diff --git a/src/main/java/frc4388/robot/subsystems/SwerveDrive.java b/src/main/java/frc4388/robot/subsystems/SwerveDrive.java index 34687d9..055230b 100644 --- a/src/main/java/frc4388/robot/subsystems/SwerveDrive.java +++ b/src/main/java/frc4388/robot/subsystems/SwerveDrive.java @@ -4,312 +4,192 @@ package frc4388.robot.subsystems; -import com.ctre.phoenix.sensors.WPI_Pigeon2; - -import edu.wpi.first.math.VecBuilder; -import edu.wpi.first.math.estimator.SwerveDrivePoseEstimator; -import edu.wpi.first.math.geometry.Pose2d; -import edu.wpi.first.math.geometry.Rotation2d; import edu.wpi.first.math.geometry.Translation2d; import edu.wpi.first.math.kinematics.ChassisSpeeds; import edu.wpi.first.math.kinematics.SwerveDriveKinematics; -import edu.wpi.first.math.kinematics.SwerveDriveOdometry; import edu.wpi.first.math.kinematics.SwerveModuleState; import edu.wpi.first.math.util.Units; -import edu.wpi.first.wpilibj.smartdashboard.Field2d; -import edu.wpi.first.wpilibj.smartdashboard.SmartDashboard; import edu.wpi.first.wpilibj2.command.SubsystemBase; -import frc4388.robot.Constants.OIConstants; import frc4388.robot.Constants.SwerveDriveConstants; -import frc4388.utility.Gains; +import frc4388.utility.RobotGyro; +import edu.wpi.first.wpilibj.smartdashboard.SmartDashboard; public class SwerveDrive extends SubsystemBase { + + private SwerveModule leftFront; + private SwerveModule rightFront; + private SwerveModule leftBack; + private SwerveModule rightBack; - private SwerveModule m_leftFront; - private SwerveModule m_leftBack; - private SwerveModule m_rightFront; - private SwerveModule m_rightBack; + private SwerveModule[] modules; - double halfWidth = SwerveDriveConstants.WIDTH / 2.d; - double halfHeight = SwerveDriveConstants.HEIGHT / 2.d; + private Translation2d leftFrontLocation = new Translation2d(Units.inchesToMeters(SwerveDriveConstants.HALF_HEIGHT), Units.inchesToMeters(SwerveDriveConstants.HALF_WIDTH)); + private Translation2d rightFrontLocation = new Translation2d(Units.inchesToMeters(SwerveDriveConstants.HALF_HEIGHT), -Units.inchesToMeters(SwerveDriveConstants.HALF_WIDTH)); + private Translation2d leftBackLocation = new Translation2d(-Units.inchesToMeters(SwerveDriveConstants.HALF_HEIGHT), Units.inchesToMeters(SwerveDriveConstants.HALF_WIDTH)); + private Translation2d rightBackLocation = new Translation2d(-Units.inchesToMeters(SwerveDriveConstants.HALF_HEIGHT), -Units.inchesToMeters(SwerveDriveConstants.HALF_WIDTH)); + + private SwerveDriveKinematics kinematics = new SwerveDriveKinematics(leftFrontLocation, rightFrontLocation, leftBackLocation, rightBackLocation); - public static Gains m_swerveGains = SwerveDriveConstants.SWERVE_GAINS; + private RobotGyro gyro; - Translation2d m_frontLeftLocation = - new Translation2d( - Units.inchesToMeters(halfHeight), - Units.inchesToMeters(halfWidth)); - Translation2d m_frontRightLocation = - new Translation2d( - Units.inchesToMeters(halfHeight), - Units.inchesToMeters(-halfWidth)); - Translation2d m_backLeftLocation = - new Translation2d( - Units.inchesToMeters(-halfHeight), - Units.inchesToMeters(halfWidth)); - Translation2d m_backRightLocation = - new Translation2d( - Units.inchesToMeters(-halfHeight), - Units.inchesToMeters(-halfWidth)); + public double speedAdjust = SwerveDriveConstants.Conversions.JOYSTICK_TO_METERS_PER_SECOND_SLOW; // * slow by default + + public double rotTarget = 0.0; + public ChassisSpeeds chassisSpeeds = new ChassisSpeeds(); - public SwerveDriveKinematics m_kinematics = new SwerveDriveKinematics(m_frontLeftLocation, m_frontRightLocation, - m_backLeftLocation, m_backRightLocation); - - public SwerveModule[] modules; - public WPI_Pigeon2 m_gyro; - - public SwerveDriveOdometry m_odometry; - // public SwerveDriveOdometry m_odometry; - - public double speedAdjust = SwerveDriveConstants.JOYSTICK_TO_METERS_PER_SECOND_SLOW; - public boolean ignoreAngles; - public Rotation2d rotTarget = new Rotation2d(); - private ChassisSpeeds chassisSpeeds = new ChassisSpeeds(); - - private final Field2d m_field = new Field2d(); - - public SwerveDrive(SwerveModule leftFront, SwerveModule leftBack, SwerveModule rightFront, SwerveModule rightBack, - WPI_Pigeon2 gyro) { - - m_leftFront = leftFront; - m_leftBack = leftBack; - m_rightFront = rightFront; - m_rightBack = rightBack; - m_gyro = gyro; - - modules = new SwerveModule[] {m_leftFront, m_rightFront, m_leftBack, m_rightBack}; + /** Creates a new SwerveDrive. */ + public SwerveDrive(SwerveModule leftFront, SwerveModule rightFront, SwerveModule leftBack, SwerveModule rightBack, RobotGyro gyro) { + this.leftFront = leftFront; + this.rightFront = rightFront; + this.leftBack = leftBack; + this.rightBack = rightBack; - // m_poseEstimator = new SwerveDrivePoseEstimator( - // getRegGyro(),//m_gyro.getRotation2d(), - // new Pose2d(), - // m_kinematics, - // VecBuilder.fill(1.0, 1.0, Units.degreesToRadians(1)), // TODO: tune - // VecBuilder.fill(Units.degreesToRadians(1)), // TODO: tune - // VecBuilder.fill(1.0, 1.0, Units.degreesToRadians(1))); // TODO: tune - - m_odometry = new SwerveDriveOdometry(m_kinematics, m_gyro.getRotation2d()); + this.gyro = gyro; - m_gyro.reset(); - SmartDashboard.putData("Field", m_field); + this.modules = new SwerveModule[] {this.leftFront, this.rightFront, this.leftBack, this.rightBack}; } - public void driveWithInput(double speedX, double speedY, double rot, boolean fieldRelative) { - Translation2d speed = new Translation2d(speedX, speedY); - driveWithInput(speed, rot, fieldRelative); - } + boolean stopped = false; + public void driveWithInput(Translation2d leftStick, Translation2d rightStick, boolean fieldRelative) { + if (fieldRelative) { - /** - * Method to drive the robot using joystick info. - * @link https://github.com/ZachOrr/MK3-Swerve-Example - * @param speeds[0] Speed of the robot in the x direction (forward). - * @param speeds[1] Speed of the robot in the y direction (sideways). - * @param rot Angular rate of the robot. - * @param fieldRelative Whether the provided x and y speeds are relative to the - * field. - */ - public void driveWithInput(Translation2d speed, double rot, boolean fieldRelative) { - ignoreAngles = (speed.getX() == 0) && (speed.getY() == 0) && (rot == 0); + double rot = 0; + + if (rightStick.getNorm() > 0.05) { + rotTarget = gyro.getAngle(); + rot = rightStick.getX() * SwerveDriveConstants.ROTATION_SPEED; + SmartDashboard.putBoolean("drift correction", false); + stopped = false; + } else if(leftStick.getNorm() > 0.05) { + if (!stopped) { + stopModules(); + stopped = true; + } - double mag = speed.getNorm(); - speed = speed.times(mag * speedAdjust); + SmartDashboard.putBoolean("drift correction", true); + rot = ((rotTarget - gyro.getAngle()) / 360) * SwerveDriveConstants.ROT_CORRECTION_SPEED; - double xSpeedMetersPerSecond = speed.getX(); - double ySpeedMetersPerSecond = speed.getY(); - chassisSpeeds = fieldRelative - ? ChassisSpeeds.fromFieldRelativeSpeeds(xSpeedMetersPerSecond, ySpeedMetersPerSecond, - -rot * SwerveDriveConstants.ROTATION_SPEED * 2, new Rotation2d(-m_gyro.getRotation2d().getRadians() + (Math.PI*2) + (Math.PI /2))) - : new ChassisSpeeds(ySpeedMetersPerSecond, -xSpeedMetersPerSecond, - -rot * SwerveDriveConstants.ROTATION_SPEED * 2); - SwerveModuleState[] states = m_kinematics.toSwerveModuleStates(chassisSpeeds); - setModuleStates(states); - } + } - public void driveWithInput(double leftX, double leftY, double rightX, double rightY, boolean fieldRelative) { - Translation2d speed = new Translation2d(leftX, leftY); - Translation2d head = new Translation2d(rightX, rightY); - driveWithInput(speed, head, fieldRelative); - } + // Use the left joystick to set speed. Apply a cubic curve and the set max speed. + Translation2d speed = leftStick.times(leftStick.getNorm() * speedAdjust); + // Translation2d cubedSpeed = new Translation2d(Math.pow(speed.getX(), 3.00), Math.pow(speed.getY(), 3.00)); - // new Rotation2d((360 - m_gyro.getRotation2d().getDegrees() + 90) * (Math.PI/180))) - public void driveWithInput(Translation2d leftStick, Translation2d rightStick, boolean fieldRelative) { - ignoreAngles = leftStick.getX() == 0 && leftStick.getY() == 0 && rightStick.getX() == 0 && rightStick.getY() == 0; - leftStick = leftStick.times(leftStick.getNorm() * speedAdjust); - if (Math.abs(rightStick.getX()) > OIConstants.RIGHT_AXIS_DEADBAND || Math.abs(rightStick.getY()) > OIConstants.RIGHT_AXIS_DEADBAND) - rotTarget = new Rotation2d(rightStick.getX(), -rightStick.getY()).minus(new Rotation2d(0,1)); - double rot = rotTarget.minus(m_gyro.getRotation2d()).getRadians(); - if (ignoreAngles) { - rot = 0; + // Convert field-relative speeds to robot-relative speeds. + chassisSpeeds = ChassisSpeeds.fromFieldRelativeSpeeds(-1 * speed.getX(), speed.getY(), rightStick.getX() * SwerveDriveConstants.ROTATION_SPEED, gyro.getRotation2d().times(-1)); + } else { + // Create robot-relative speeds. + chassisSpeeds = new ChassisSpeeds(-1 * leftStick.getX(), leftStick.getY(), rightStick.getX() * SwerveDriveConstants.ROTATION_SPEED); } - double xSpeedMetersPerSecond = leftStick.getX(); - double ySpeedMetersPerSecond = leftStick.getY(); - chassisSpeeds = fieldRelative - ? ChassisSpeeds.fromFieldRelativeSpeeds(xSpeedMetersPerSecond, ySpeedMetersPerSecond, - rot * SwerveDriveConstants.ROTATION_SPEED * 2, new Rotation2d(-m_gyro.getRotation2d().getRadians() + (Math.PI*2) + (Math.PI /2))) - : new ChassisSpeeds(xSpeedMetersPerSecond, ySpeedMetersPerSecond, rightStick.getX() * SwerveDriveConstants.ROTATION_SPEED * 2); - SwerveModuleState[] states = m_kinematics.toSwerveModuleStates( - chassisSpeeds); - // if (ignoreAngles) { - // SwerveModuleState[] lockedStates = new SwerveModuleState[states.length]; - // for (int i = 0; i < states.length; i ++) { - // SwerveModuleState state = states[i]; - // lockedStates[i]= new SwerveModuleState(0, state.angle); - // } - // setModuleStates(lockedStates); - // } - setModuleStates(states); - // SmartDashboard.putNumber("rot", rot); - // SmartDashboard.putNumber("rotarget", rotTarget.getDegrees()); + setModuleStates(kinematics.toSwerveModuleStates(chassisSpeeds)); } /** * Set each module of the swerve drive to the corresponding desired state. - * * @param desiredStates Array of module states to set. */ public void setModuleStates(SwerveModuleState[] desiredStates) { - SwerveDriveKinematics.desaturateWheelSpeeds(desiredStates, - Units.feetToMeters(SwerveDriveConstants.MAX_SPEED_FEET_PER_SEC)); - // int i = 2; { + SwerveDriveKinematics.desaturateWheelSpeeds(desiredStates, Units.feetToMeters(SwerveDriveConstants.MAX_SPEED_FEET_PER_SECOND)); for (int i = 0; i < desiredStates.length; i++) { SwerveModule module = modules[i]; SwerveModuleState state = desiredStates[i]; - module.setDesiredState(state, ignoreAngles); + module.setDesiredState(state); } - // modules[0].setDesiredState(desiredStates[0], false); } - public void setModuleRotationsToAngle(double angle) { - for (int i = 0; i < modules.length; i++) { - SwerveModule module = modules[i]; - module.rotateToAngle(angle); + public boolean rotateToTarget(double angle) { + double currentAngle = getGyroAngle(); + double error = angle - currentAngle; + + driveWithInput(new Translation2d(0, 0), new Translation2d(error / Math.abs(error) * 0.3, 0), true); + + if (Math.abs(angle - getGyroAngle()) < 5.0) { + return true; } + + return false; + } + + public double getGyroAngle() { + return gyro.getAngle(); + } + + public void resetGyro() { + gyro.reset(); + rotTarget = 0.0; + } + + public void stopModules() { + for (SwerveModule module : this.modules) { + module.stop(); + } + } + + public SwerveDriveKinematics getKinematics() { + return this.kinematics; } @Override public void periodic() { - updateOdometry(); - updateSmartDash(); - - // SmartDashboard.putNumber("Pigeon getRotation2d", m_gyro.getRotation2d().getDegrees()); - // SmartDashboard.putNumber("Pigeon getAngle", m_gyro.getAngle()); - // SmartDashboard.putNumber("Pigeon Yaw", m_gyro.getYaw()); - // SmartDashboard.putNumber("Pigeon Yaw (0 to 360)", m_gyro.getYaw() % 360); - - m_field.setRobotPose(getOdometry()); - super.periodic(); + // This method will be called once per scheduler run\ + SmartDashboard.putNumber("Gyro", getGyroAngle()); } - private void updateSmartDash() { - // odometry - SmartDashboard.putNumber("Odometry: X", getOdometry().getX()); - SmartDashboard.putNumber("Odometry: Y", getOdometry().getY()); - SmartDashboard.putNumber("Odometry: Theta", getOdometry().getRotation().getDegrees()); - - // chassis speeds - // TODO: find the actual max velocity in m/s of the robot in fast mode to have accurate chassis speeds - // SmartDashboard.putNumber("Chassis Vel: X", chassisSpeeds.vxMetersPerSecond); - // SmartDashboard.putNumber("Chassis Vel: Y", chassisSpeeds.vyMetersPerSecond); - // SmartDashboard.putNumber("Chassis Vel: ω", chassisSpeeds.omegaRadiansPerSecond); - } - - /** - * Gets the current chassis speeds in m/s and rad/s. - * @return Current chassis speeds (vx, vy, ω) - */ - public ChassisSpeeds getChassisSpeeds() { - return chassisSpeeds; - } - - /** - * Gets the current pose of the robot. - * - * @return Robot's current pose. - */ - public Pose2d getOdometry() { - // return m_odometry.getPoseMeters(); - return m_odometry.getPoseMeters(); - // return m_poseEstimator.getEstimatedPosition(); - } - - public Pose2d getAutoOdo() { - Pose2d workingPose = getOdometry(); - return new Pose2d(-workingPose.getX(), workingPose.getY(), workingPose.getRotation()); - } - - /** - * Gets the current gyro using regression formula. - * - * @return Rotation2d object holding current gyro in radians - */ - public Rotation2d getRegGyro() { - // * test chassis regression - // double regCur = 0.6552670369 + m_gyro.getRotation2d().getDegrees() * 0.9926871527; - // * new robot regression - double regCur = 0.2507023948 + m_gyro.getRotation2d().getDegrees() * 0.999034743; - return new Rotation2d(Math.toRadians(regCur)); - } - - /** - * Resets the odometry of the robot to the given pose. - */ - public void resetOdometry(Pose2d pose) { - m_odometry.resetPosition(pose, m_gyro.getRotation2d()); - } - - /** - * Updates the field relative position of the robot. - */ - public void updateOdometry() { - Rotation2d actualDWI = new Rotation2d(-m_gyro.getRotation2d().getRadians() + (Math.PI*2)); //+ (Math.PI/2)); - Rotation2d actual = new Rotation2d(m_gyro.getRotation2d().getRadians()); - - SmartDashboard.putNumber("AUTO ACTUAL GYRO", actual.getDegrees()); - SmartDashboard.putNumber("AUTO DWI GYRO", actual.getDegrees()); - - m_odometry.update( actual,//m_gyro.getRotation2d(),//new Rotation2d((2 * Math.PI) - getRegGyro().getRadians()), - modules[0].getState(), - modules[1].getState(), - modules[2].getState(), - modules[3].getState()); - } - - - /** - * Resets pigeon. - */ - public void resetGyro() { - m_gyro.reset(); - rotTarget = new Rotation2d(0); - } - - /** - * Stop all four swerve modules. - */ - public void stopModules() { - modules[0].stop(); - modules[1].stop(); - modules[2].stop(); - modules[3].stop(); - } - - /** - * Switches speed modes. - * - * @param shift True if fast mode, false if slow mode. - */ - public void highSpeed(boolean shift) { - if (shift) { - speedAdjust = SwerveDriveConstants.JOYSTICK_TO_METERS_PER_SECOND_FAST; + public void shiftDown() { + if (Math.abs(this.speedAdjust - SwerveDriveConstants.SLOW_SPEED) < .01) { + + } else if (Math.abs(this.speedAdjust - SwerveDriveConstants.FAST_SPEED) < .01) { + this.speedAdjust = SwerveDriveConstants.SLOW_SPEED; } else { - speedAdjust = SwerveDriveConstants.JOYSTICK_TO_METERS_PER_SECOND_SLOW; + this.speedAdjust = SwerveDriveConstants.FAST_SPEED; } } - public double getCurrent(){ - return m_leftFront.getCurrent() + m_rightFront.getCurrent() + m_rightBack.getCurrent() + m_leftBack.getCurrent(); + public void setToSlow() { + this.speedAdjust = SwerveDriveConstants.SLOW_SPEED; + System.out.println("SLOW"); + System.out.println("SLOW"); + System.out.println("SLOW"); + System.out.println("SLOW"); + System.out.println("SLOW"); } - public double getVoltage(){ - return m_leftFront.getVoltage() + m_rightFront.getVoltage() + m_rightBack.getVoltage() + m_leftBack.getVoltage(); + public void setToFast() { + this.speedAdjust = SwerveDriveConstants.FAST_SPEED; + System.out.println("FAST"); + System.out.println("FAST"); + System.out.println("FAST"); + System.out.println("FAST"); + System.out.println("FAST"); } -} \ No newline at end of file + + public void setToTurbo() { + this.speedAdjust = SwerveDriveConstants.TURBO_SPEED; + System.out.println("TURBO"); + System.out.println("TURBO"); + System.out.println("TURBO"); + System.out.println("TURBO"); + System.out.println("TURBO"); + } + + public void shiftUp() { + if (Math.abs(this.speedAdjust - SwerveDriveConstants.SLOW_SPEED) < .01) { + this.speedAdjust = SwerveDriveConstants.FAST_SPEED; + } else if (Math.abs(this.speedAdjust - SwerveDriveConstants.FAST_SPEED) < .01) { + this.speedAdjust = SwerveDriveConstants.TURBO_SPEED; + } else { + + } + } + + public void toggleGear(double angle) { + if (Math.abs(this.speedAdjust - SwerveDriveConstants.Conversions.JOYSTICK_TO_METERS_PER_SECOND_SLOW) < .01 && Math.abs(angle) < 10) { + this.speedAdjust = SwerveDriveConstants.Conversions.JOYSTICK_TO_METERS_PER_SECOND_FAST; + SwerveDriveConstants.ROT_CORRECTION_SPEED = SwerveDriveConstants.CORRECTION_MIN; + } else { + this.speedAdjust = SwerveDriveConstants.Conversions.JOYSTICK_TO_METERS_PER_SECOND_SLOW; + SwerveDriveConstants.ROT_CORRECTION_SPEED = SwerveDriveConstants.CORRECTION_MIN; + } + } + +} diff --git a/src/main/java/frc4388/robot/subsystems/SwerveModule.java b/src/main/java/frc4388/robot/subsystems/SwerveModule.java index 68c383d..1ddab51 100644 --- a/src/main/java/frc4388/robot/subsystems/SwerveModule.java +++ b/src/main/java/frc4388/robot/subsystems/SwerveModule.java @@ -7,175 +7,155 @@ package frc4388.robot.subsystems; import com.ctre.phoenix.motorcontrol.FeedbackDevice; import com.ctre.phoenix.motorcontrol.RemoteSensorSource; import com.ctre.phoenix.motorcontrol.TalonFXControlMode; -import com.ctre.phoenix.motorcontrol.TalonFXFeedbackDevice; import com.ctre.phoenix.motorcontrol.can.TalonFXConfiguration; import com.ctre.phoenix.motorcontrol.can.WPI_TalonFX; import com.ctre.phoenix.sensors.CANCoder; -import com.ctre.phoenix.sensors.CANCoderConfiguration; import edu.wpi.first.math.geometry.Rotation2d; +import edu.wpi.first.math.kinematics.SwerveModulePosition; import edu.wpi.first.math.kinematics.SwerveModuleState; import edu.wpi.first.math.util.Units; -import edu.wpi.first.wpilibj.smartdashboard.SmartDashboard; import edu.wpi.first.wpilibj2.command.SubsystemBase; import frc4388.robot.Constants.SwerveDriveConstants; import frc4388.utility.Gains; public class SwerveModule extends SubsystemBase { - public WPI_TalonFX angleMotor; - public WPI_TalonFX driveMotor; - private CANCoder canCoder; - public static Gains m_swerveGains = SwerveDriveConstants.SWERVE_GAINS; - - private static double kEncoderTicksPerRotation = 4096; - private SwerveModuleState state; - private double canCoderFeedbackCoefficient; - - public long m_currentTime; - public long m_lastTime; - public double m_deltaTime; - - public double m_currentPos; - public double m_lastPos; - - public SwerveModuleState lastState = new SwerveModuleState(); - public SwerveModuleState currentState; + private WPI_TalonFX driveMotor; + private WPI_TalonFX angleMotor; + private CANCoder encoder; + public static Gains swerveGains = SwerveDriveConstants.PIDConstants.SWERVE_GAINS; + /** Creates a new SwerveModule. */ - public SwerveModule(WPI_TalonFX driveMotor, WPI_TalonFX angleMotor, CANCoder canCoder, double offset) { + public SwerveModule(WPI_TalonFX driveMotor, WPI_TalonFX angleMotor, CANCoder encoder, double offset) { this.driveMotor = driveMotor; this.angleMotor = angleMotor; - this.canCoder = canCoder; - canCoderFeedbackCoefficient = canCoder.configGetFeedbackCoefficient(); + this.encoder = encoder; - TalonFXConfiguration angleTalonFXConfiguration = new TalonFXConfiguration(); + TalonFXConfiguration angleConfig = new TalonFXConfiguration(); + angleConfig.slot0.kP = swerveGains.kP; + angleConfig.slot0.kI = swerveGains.kI; + angleConfig.slot0.kD = swerveGains.kD; - angleTalonFXConfiguration.slot0.kP = m_swerveGains.kP; - angleTalonFXConfiguration.slot0.kI = m_swerveGains.kI; - angleTalonFXConfiguration.slot0.kD = m_swerveGains.kD; + // use the CANcoder as the remote sensor for the primary TalonFX PID + angleConfig.remoteFilter0.remoteSensorDeviceID = encoder.getDeviceID(); + angleConfig.remoteFilter0.remoteSensorSource = RemoteSensorSource.CANCoder; + angleConfig.primaryPID.selectedFeedbackSensor = FeedbackDevice.RemoteSensor0; + angleMotor.configAllSettings(angleConfig); - // Use the CANCoder as the remote sensor for the primary TalonFX PID - angleTalonFXConfiguration.remoteFilter0.remoteSensorDeviceID = canCoder.getDeviceID(); - angleTalonFXConfiguration.remoteFilter0.remoteSensorSource = RemoteSensorSource.CANCoder; - angleTalonFXConfiguration.primaryPID.selectedFeedbackSensor = FeedbackDevice.RemoteSensor0; - angleMotor.configAllSettings(angleTalonFXConfiguration); - // angleMotor.setInverted(true); - // TalonFXConfiguration driveTalonFXConfiguration = new TalonFXConfiguration(); - // driveTalonFXConfiguration.slot0.kP = 0.05; - // driveTalonFXConfiguration.slot0.kI = 0.0; - // driveTalonFXConfiguration.slot0.kD = 0.0; - // driveTalonFXConfiguration.primaryPID.selectedFeedbackSensor = - // FeedbackDevice.IntegratedSensor; - driveMotor.configFactoryDefault(); - driveMotor.configSelectedFeedbackSensor(TalonFXFeedbackDevice.IntegratedSensor, 0, 30); - driveMotor.configNominalOutputForward(0, 30); - driveMotor.configNominalOutputReverse(0, 30); - driveMotor.configPeakOutputForward(1, 30); - driveMotor.configPeakOutputReverse(-1, 30); - driveMotor.configAllowableClosedloopError(0, 0, 30); - // driveMotor.setInverted(true); - driveMotor.config_kP(0, 0, 30); - driveMotor.config_kI(0, 0, 30); - driveMotor.config_kD(0, 0, 30); + encoder.configMagnetOffset(offset); - // driveMotor.configAllSettings(driveTalonFXConfiguration); - - CANCoderConfiguration canCoderConfiguration = new CANCoderConfiguration(); - canCoderConfiguration.sensorCoefficient = 0.087890625; - canCoderConfiguration.magnetOffsetDegrees = offset; - canCoderConfiguration.sensorDirection = true; - canCoder.configAllSettings(canCoderConfiguration); - - m_currentTime = System.currentTimeMillis(); - m_lastTime = System.currentTimeMillis(); - - m_lastPos = driveMotor.getSelectedSensorPosition(); - } - - private Rotation2d getAngle() { - // ! Note: This assumes the CANCoders are setup with the default feedback coefficient and the sensor value reports degrees. - return Rotation2d.fromDegrees(canCoder.getAbsolutePosition()); + driveMotor.setSelectedSensorPosition(0); + driveMotor.config_kP(0, 0.2); } /** - * Set the speed + rotation of the swerve module from a SwerveModuleState object - * - * @param desiredState - A SwerveModuleState representing the desired new state - * of the module + * Get the drive motor of the SwerveModule + * @return the drive motor of the SwerveModule */ - public void setDesiredState(SwerveModuleState desiredState, boolean ignoreAngle) { - Rotation2d currentRotation = getAngle(); - // currentRotation.getDegrees()); - state = SwerveModuleState.optimize(desiredState, currentRotation); - - // Find the difference between our current rotational position + our new - // rotational position - Rotation2d rotationDelta = state.angle.minus(currentRotation); - - // Find the new absolute position of the module based on the difference in - // rotation - double deltaTicks = (rotationDelta.getDegrees() / 360.) * kEncoderTicksPerRotation; - // Convert the CANCoder from it's position reading back to ticks - double currentTicks = canCoder.getPosition() / canCoderFeedbackCoefficient; - double desiredTicks = currentTicks + deltaTicks; - - if (!ignoreAngle) { - angleMotor.set(TalonFXControlMode.Position, desiredTicks); - } - - // Please work - double ftPerSec = Units.metersToFeet(state.speedMetersPerSecond); - double normFtPerSec = ftPerSec / SwerveDriveConstants.MAX_SPEED_FEET_PER_SEC; - // double angleCorrection = angleMotor.getSelectedSensorVelocity() * 2.69; - driveMotor.set(normFtPerSec);// - angleMotor.get()); - // driveMotor.set(TalonFXControlMode.Velocity, angleCorrection); // Ratio - // between axis = 1/1.75 Ratio of wheel is 5.14/1 ratio of steer is 12.8/1 + public WPI_TalonFX getDriveMotor() { + return this.driveMotor; } /** - * Get current module state. - * - * @return The current state of the module in m/s. + * Get the angle motor of the SwerveModule + * @return the angle motor of the SwerveModule */ - public SwerveModuleState getState() { - // return state; - return new SwerveModuleState(driveMotor.getSelectedSensorVelocity() * SwerveDriveConstants.INCHES_PER_TICK - * SwerveDriveConstants.METERS_PER_INCH * 10, getAngle()); + public WPI_TalonFX getAngleMotor() { + return this.angleMotor; } /** - * Stop the drive and steer motors of current module. + * Get the CANcoder of the SwerveModule + * @return the CANcoder of the SwerveModule */ + public CANCoder getEncoder() { + return this.encoder; + } + + /** + * Get the angle of a SwerveModule as a Rotation2d + * @return the angle of a SwerveModule as a Rotation2d + */ + public Rotation2d getAngle() { + // * Note: This assumes that the CANCoders are setup with the default feedback coefficient and the sensor value reports degrees. + return Rotation2d.fromDegrees(encoder.getAbsolutePosition()); + } + + public double getAngularVel() { + return this.angleMotor.getSelectedSensorVelocity(); + } + + public double getDrivePos() { + return this.driveMotor.getSelectedSensorPosition() / SwerveDriveConstants.Conversions.TICKS_PER_MOTOR_REV; + } + + public double getDriveVel() { + return this.driveMotor.getSelectedSensorVelocity(0); + } + public void stop() { driveMotor.set(0); angleMotor.set(0); } public void rotateToAngle(double angle) { - this.angleMotor.set(TalonFXControlMode.Position, angle); + angleMotor.set(TalonFXControlMode.Position, angle); } - @Override - public void periodic() { - currentState = this.getState(); - - Rotation2d currentRotation = getAngle(); - SmartDashboard.putNumber("Angle Motor " + angleMotor.getDeviceID(), currentRotation.getDegrees()); - SmartDashboard.putNumber("Drive Motor " + driveMotor.getDeviceID(), - ((driveMotor.getSelectedSensorPosition() / 2048) * 360) % 360); - - lastState = currentState; + /** + * Get state of swerve module + * @return speed in m/s and angle in degrees + */ + public SwerveModuleState getState() { + return new SwerveModuleState( + Units.inchesToMeters(driveMotor.getSelectedSensorVelocity() * SwerveDriveConstants.Conversions.INCHES_PER_TICK) * SwerveDriveConstants.Conversions.TICK_TIME_TO_SECONDS, + getAngle() + ); } - public void reset() { - canCoder.setPositionToAbsolute(); - // canCoder.configSensorInitializationStrategy(initializationStrategy) + /** + * Returns the current position of the SwerveModule + * @return The current position of the SwerveModule in meters traveled by the driveMotor and the angle of the angleMotor. + */ + public SwerveModulePosition getPosition() { + return new SwerveModulePosition(Units.inchesToMeters(driveMotor.getSelectedSensorPosition() * SwerveDriveConstants.Conversions.INCHES_PER_TICK), getAngle()); } - public double getCurrent(){ + + /** + * Set the speed and rotation of the SwerveModule from a SwerveModuleState object + * @param desiredState a SwerveModuleState representing the desired new state of the module + */ + public void setDesiredState(SwerveModuleState desiredState) { + Rotation2d currentRotation = this.getAngle(); + + SwerveModuleState state = SwerveModuleState.optimize(desiredState, currentRotation); + + // calculate the difference between our current rotational position and our new rotational position + Rotation2d rotationDelta = state.angle.minus(currentRotation); + + // calculate the new absolute position of the SwerveModule based on the difference in rotation + double deltaTicks = (rotationDelta.getDegrees() / 360.) * SwerveDriveConstants.Conversions.CANCODER_TICKS_PER_ROTATION; + + // convert the CANCoder from its position reading to ticks + double currentTicks = encoder.getPosition() / encoder.configGetFeedbackCoefficient(); + + angleMotor.set(TalonFXControlMode.Position, currentTicks + deltaTicks); + + double feetPerSecond = Units.metersToFeet(state.speedMetersPerSecond); + + driveMotor.set((feetPerSecond / SwerveDriveConstants.MAX_SPEED_FEET_PER_SECOND)); + } + + public void reset(double position) { + encoder.setPositionToAbsolute(); + } + + public double getCurrent() { return angleMotor.getSupplyCurrent() + driveMotor.getSupplyCurrent(); } - public double getVoltage(){ + public double getVoltage() { return (Math.abs(angleMotor.getMotorOutputVoltage()) + Math.abs(driveMotor.getMotorOutputVoltage())); } -} \ No newline at end of file +} diff --git a/src/main/java/frc4388/utility/Gains.java b/src/main/java/frc4388/utility/Gains.java new file mode 100644 index 0000000..7a3a026 --- /dev/null +++ b/src/main/java/frc4388/utility/Gains.java @@ -0,0 +1,83 @@ +// 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 frc4388.utility; + +/** Add your docs here. */ +public class Gains { + public double kP; + public double kI; + public double kD; + public double kF; + public int kIZone; + public double kPeakOutput; + public double kMaxOutput; + public double kMinOutput; + + /** + * Creates Gains object for PIDs + * @param kP The P value. + * @param kI The I value. + * @param kD The D value. + * @param kF The F value. + * @param kIZone The zone of the I value. + * @param kPeakOutput The peak output setting the motors to run the gains at, in both forward and reverse directions. By default 1.0. + */ + public Gains(double kP, double kI, double kD, double kF, int kIZone, double kPeakOutput) { + this.kP = kP; + this.kI = kI; + this.kD = kD; + this.kF = kF; + this.kIZone = kIZone; + this.kPeakOutput = kPeakOutput; + this.kMaxOutput = kPeakOutput; + this.kMinOutput = -kPeakOutput; + } + + /** + * Creates Gains object for PIDs + * @param kP The P value. + * @param kI The I value. + * @param kD The D value. + * @param kF The F value. + * @param kIZone The zone of the I value. + */ + public Gains(double kP, double kI, double kD, double kF, int kIZone) { + this.kP = kP; + this.kI = kI; + this.kD = kD; + this.kF = kF; + this.kIZone = kIZone; + this.kPeakOutput = 1.0; + this.kMaxOutput = 1.0; + this.kMinOutput = -1.0; + } + + public Gains(double kP, double kI, double kD) { + this.kP = kP; + this.kI = kI; + this.kD = kD; + } + + /** + * Creates Gains object for PIDs + * @param kP The P value. + * @param kI The I value. + * @param kD The D value. + * @param kF The F value. + * @param kIZone The zone of the I value. + * @param kMinOutput The lowest output setting to run the gains at, usually in the reverse direction. By default -1.0. + * @param kMaxOutput The highest output setting to run the gains at, usually in the forward direction. By default 1.0. + */ + public Gains(double kP, double kI, double kD, double kF, int kIZone, double kMaxOutput, double kMinOutput) { + this.kP = kP; + this.kI = kI; + this.kD = kD; + this.kF = kF; + this.kIZone = kIZone; + this.kMaxOutput = kMaxOutput; + this.kMinOutput = kMinOutput; + this.kPeakOutput = (Math.abs(kMinOutput) > Math.abs(kMaxOutput)) ? Math.abs(kMinOutput) : Math.abs(kMaxOutput); + } +} \ No newline at end of file diff --git a/src/main/java/frc4388/utility/RobotGyro.java b/src/main/java/frc4388/utility/RobotGyro.java index a42e8c8..a037914 100644 --- a/src/main/java/frc4388/utility/RobotGyro.java +++ b/src/main/java/frc4388/utility/RobotGyro.java @@ -7,31 +7,34 @@ package frc4388.utility; -import com.ctre.phoenix.sensors.PigeonIMU; -import com.ctre.phoenix.sensors.PigeonIMU.CalibrationMode; +import com.ctre.phoenix.sensors.WPI_Pigeon2; import com.kauailabs.navx.frc.AHRS; -import edu.wpi.first.wpilibj.GyroBase; -import edu.wpi.first.wpiutil.math.MathUtil; +// import edu.wpi.first.wpilibj.GyroBase; +import edu.wpi.first.wpilibj.interfaces.Gyro; +import edu.wpi.first.math.MathUtil; /** * Gyro class that allows for interchangeable use between a pigeon and a navX */ -public class RobotGyro extends GyroBase { +public class RobotGyro implements Gyro { private RobotTime m_robotTime = RobotTime.getInstance(); - private PigeonIMU m_pigeon = null; + private WPI_Pigeon2 m_pigeon = null; private AHRS m_navX = null; public boolean m_isGyroAPigeon; //true if pigeon, false if navX private double m_lastPigeonAngle; private double m_deltaPigeonAngle; + private double pitchZero = 0; + private double rollZero = 0; + /** * Creates a Gyro based on a pigeon * @param gyro the gyroscope to use for Gyro */ - public RobotGyro(PigeonIMU gyro) { + public RobotGyro(WPI_Pigeon2 gyro) { m_pigeon = gyro; m_isGyroAPigeon = true; } @@ -45,6 +48,16 @@ public class RobotGyro extends GyroBase { m_isGyroAPigeon = false; } + /** + * Resets yaw, pitch, and roll. + */ + public void resetZeroValues() { + if (!m_isGyroAPigeon) return; + + pitchZero = m_pigeon.getPitch(); + rollZero = m_pigeon.getRoll(); + } + /** * Run in periodic if you are using a pigeon. Updates a delta angle so that it can calculate getRate(). Note * that the getRate() method for a navX will likely be much more accurate than for a pigeon. @@ -74,7 +87,7 @@ public class RobotGyro extends GyroBase { @Override public void calibrate() { if (m_isGyroAPigeon) { - m_pigeon.enterCalibrationMode(CalibrationMode.Temperature); + m_pigeon.calibrate(); } else { m_navX.calibrate(); } @@ -82,6 +95,8 @@ public class RobotGyro extends GyroBase { @Override public void reset() { + resetZeroValues(); + if (m_isGyroAPigeon) { m_pigeon.setYaw(0); } else { @@ -98,9 +113,10 @@ public class RobotGyro extends GyroBase { * Roll is within [-90,+90] degrees. */ private double[] getPigeonAngles() { - double[] angles = new double[3]; - m_pigeon.getYawPitchRoll(angles); - return angles; + double[] ypr = new double[3]; + m_pigeon.getYawPitchRoll(ypr); + + return new double[] {ypr[0], (ypr[1] - pitchZero), (ypr[2] - rollZero)}; } @Override @@ -112,6 +128,10 @@ public class RobotGyro extends GyroBase { } } + public double getYaw() { + return this.getAngle(); + } + /** * Gets an absolute heading of the robot * @return heading from -180 to 180 degrees @@ -165,7 +185,7 @@ public class RobotGyro extends GyroBase { } } - public PigeonIMU getPigeon(){ + public WPI_Pigeon2 getPigeon(){ return m_pigeon; } diff --git a/src/main/java/frc4388/utility/controller/XboxTriggerButton.java b/src/main/java/frc4388/utility/controller/XboxTriggerButton.java index 26372c2..8c2fe88 100644 --- a/src/main/java/frc4388/utility/controller/XboxTriggerButton.java +++ b/src/main/java/frc4388/utility/controller/XboxTriggerButton.java @@ -1,7 +1,6 @@ package frc4388.utility.controller; import edu.wpi.first.wpilibj2.command.button.Button; -import frc4388.utility.controller.XboxController; /** * Mapping for the Xbox controller triggers to allow triggers to be defined as @@ -32,7 +31,7 @@ public class XboxTriggerButton extends Button { } /** {@inheritDoc} */ - @Override + // @Override public boolean get() { if (m_trigger == RIGHT_TRIGGER) { return m_controller.getRightTrigger(); diff --git a/src/test/java/frc4388/robot/subsystems/LEDSubsystemTest.old b/src/test/java/frc4388/robot/subsystems/LEDSubsystemTest.old new file mode 100644 index 0000000..8fcbf53 --- /dev/null +++ b/src/test/java/frc4388/robot/subsystems/LEDSubsystemTest.old @@ -0,0 +1,59 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018-2019 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package frc4388.robot.subsystems; + +import static org.junit.Assert.assertEquals; +import static org.mockito.Mockito.mock; + +import org.junit.Test; + +import edu.wpi.first.wpilibj.*; +import frc4388.robot.Constants.LEDConstants; +import frc4388.utility.LEDPatterns; + +/** + * Add your docs here. + */ +public class LEDSubsystemTest { + @Test + public void testConstructor() { + // Arrange + Spark ledController = mock(Spark.class); + + // Act + LED led = new LED(ledController); + + // Assert + assertEquals(LEDConstants.DEFAULT_PATTERN.getValue(), led.getPattern().getValue(), 0.0001); + } + + @Test + public void testPatterns() { + // Arrange + Spark ledController = mock(Spark.class); + LED led = new LED(ledController); + + // Act + led.setPattern(LEDPatterns.RAINBOW_RAINBOW); + + // Assert + assertEquals(LEDPatterns.RAINBOW_RAINBOW.getValue(), led.getPattern().getValue(), 0.0001); + + // Act + led.setPattern(LEDPatterns.BLUE_BREATH); + + // Assert + assertEquals(LEDPatterns.BLUE_BREATH.getValue(), led.getPattern().getValue(), 0.0001); + + // Act + led.setPattern(LEDPatterns.SOLID_BLACK); + + // Assert + assertEquals(LEDPatterns.SOLID_BLACK.getValue(), led.getPattern().getValue(), 0.0001); + } +} diff --git a/src/test/java/frc4388/utility/RobotGyroUtilityTest.old b/src/test/java/frc4388/utility/RobotGyroUtilityTest.old new file mode 100644 index 0000000..8c0b1e5 --- /dev/null +++ b/src/test/java/frc4388/utility/RobotGyroUtilityTest.old @@ -0,0 +1,184 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018-2019 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package frc4388.utility; + +import static org.junit.Assert.*; +import static org.mockito.Mockito.*; + +import com.kauailabs.navx.frc.AHRS; + +import org.junit.*; + +import frc4388.mocks.MockPigeonIMU; +import frc4388.robot.Constants.DriveConstants; + +/** + * Add your docs here. + */ +public class RobotGyroUtilityTest { + // TODO UNTESTED: most functions for NavX + + private RobotGyro gyroPigeon; + private RobotGyro gyroNavX; + + @Test + public void testConstructor() { + // Arrange + MockPigeonIMU pigeon = new MockPigeonIMU(DriveConstants.DRIVE_PIGEON_ID); + AHRS navX = mock(AHRS.class); + gyroPigeon = new RobotGyro(pigeon); + gyroNavX = new RobotGyro(navX); + + // Assert + assertEquals(true, gyroPigeon.m_isGyroAPigeon); + assertEquals(pigeon, gyroPigeon.getPigeon()); + assertEquals(null, gyroPigeon.getNavX()); + assertEquals(false, gyroNavX.m_isGyroAPigeon); + assertEquals(navX, gyroNavX.getNavX()); + assertEquals(null, gyroNavX.getPigeon()); + } + + @Test + public void testHeadingPigeon() { + // Arrange + MockPigeonIMU pigeon = new MockPigeonIMU(DriveConstants.DRIVE_PIGEON_ID); + gyroPigeon = new RobotGyro(pigeon); + + // Act & Assert + assertEquals(-90, gyroPigeon.getHeading(270), 0.0001); + assertEquals(-45, gyroPigeon.getHeading(315), 0.0001); + assertEquals(-60, gyroPigeon.getHeading(-60), 0.0001); + assertEquals(30, gyroPigeon.getHeading(30), 0.0001); + assertEquals(0, gyroPigeon.getHeading(0), 0.0001); + assertEquals(180, gyroPigeon.getHeading(180), 0.0001); + assertEquals(-180, gyroPigeon.getHeading(-180), 0.0001); + assertEquals(97, gyroPigeon.getHeading(1537), 0.0001); + assertEquals(99, gyroPigeon.getHeading(-2781), 0.0001); + } + + @Test + public void testYawPitchRollPigeon() { + // Arrange + MockPigeonIMU pigeon = new MockPigeonIMU(DriveConstants.DRIVE_PIGEON_ID); + gyroPigeon = new RobotGyro(pigeon); + + // Assert + assertEquals(0, gyroPigeon.getAngle(), 0.0001); + + // Act + pigeon.setYaw(40); + + // Assert + assertEquals(40, gyroPigeon.getAngle(), 0.0001); + + // Act + gyroPigeon.reset(); + + // Assert + assertEquals(0, gyroPigeon.getAngle(), 0.0001); + + // Act + pigeon.setYaw(-1457); + pigeon.setCurrentPitch(100); + pigeon.setCurrentRoll(100); + + // Assert + assertEquals(-1457, gyroPigeon.getAngle(), 0.0001); + assertEquals(90, gyroPigeon.getPitch(), 0.0001); + assertEquals(90, gyroPigeon.getRoll(), 0.0001); + + // Act + pigeon.setCurrentPitch(45); + pigeon.setCurrentRoll(45); + + // Assert + assertEquals(45, gyroPigeon.getPitch(), 0.0001); + assertEquals(45, gyroPigeon.getRoll(), 0.0001); + + // Act + pigeon.setCurrentPitch(0); + pigeon.setCurrentRoll(0); + + // Assert + assertEquals(0, gyroPigeon.getPitch(), 0.0001); + assertEquals(0, gyroPigeon.getRoll(), 0.0001); + + // Act + pigeon.setCurrentPitch(-60); + pigeon.setCurrentRoll(-60); + + // Assert + assertEquals(-60, gyroPigeon.getPitch(), 0.0001); + assertEquals(-60, gyroPigeon.getRoll(), 0.0001); + + // Act + pigeon.setCurrentPitch(-90); + pigeon.setCurrentRoll(-90); + + // Assert + assertEquals(-90, gyroPigeon.getPitch(), 0.0001); + assertEquals(-90, gyroPigeon.getRoll(), 0.0001); + + // Act + pigeon.setCurrentPitch(-100); + pigeon.setCurrentRoll(-100); + + // Assert + assertEquals(-90, gyroPigeon.getPitch(), 0.0001); + assertEquals(-90, gyroPigeon.getRoll(), 0.0001); + } + + @Test + public void testRatesPigeon() { + // Arrange + MockPigeonIMU pigeon = new MockPigeonIMU(DriveConstants.DRIVE_PIGEON_ID); + gyroPigeon = new RobotGyro(pigeon); + RobotTime robotTime = RobotTime.getInstance(); + gyroPigeon.updatePigeonDeltas(); + + // Act + robotTime.m_deltaTime = 5; + pigeon.setYaw(0); + gyroPigeon.updatePigeonDeltas(); + + // Assert + assertEquals(0, gyroPigeon.getRate(), 1); + + // Act + robotTime.m_deltaTime = 5; + pigeon.setYaw(90); + gyroPigeon.updatePigeonDeltas(); + + // Assert + assertEquals(18000, gyroPigeon.getRate(), 0.001); + + // Act + robotTime.m_deltaTime = 5; + pigeon.setYaw(90); + gyroPigeon.updatePigeonDeltas(); + + // Assert + assertEquals(0, gyroPigeon.getRate(), 0.001); + + // Act + robotTime.m_deltaTime = 3; + pigeon.setYaw(-30); + gyroPigeon.updatePigeonDeltas(); + + // Assert + assertEquals(-40000, gyroPigeon.getRate(), 0.001); + + // Act + robotTime.m_deltaTime = 6; + pigeon.setYaw(690); + gyroPigeon.updatePigeonDeltas(); + + // Assert + assertEquals(120000, gyroPigeon.getRate(), 0.001); + } +} diff --git a/src/test/java/frc4388/utility/RobotTimeUtilityTest.old b/src/test/java/frc4388/utility/RobotTimeUtilityTest.old new file mode 100644 index 0000000..2c31a34 --- /dev/null +++ b/src/test/java/frc4388/utility/RobotTimeUtilityTest.old @@ -0,0 +1,104 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018-2019 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package frc4388.utility; + +import static org.junit.Assert.*; + +import org.junit.*; + +/** + * Add your docs here. + */ +public class RobotTimeUtilityTest { + RobotTime robotTime = RobotTime.getInstance(); + + @Test + public void testUpdateTimes() { + // Arrange + long lastTime; + robotTime.m_deltaTime = 0; + robotTime.m_robotTime = 0; + robotTime.m_lastRobotTime = 0; + robotTime.m_frameNumber = 0; + robotTime.endMatchTime(); + robotTime.m_lastMatchTime = 0; + + // Assert + assertEquals(0, robotTime.m_deltaTime); + assertEquals(0, robotTime.m_robotTime); + assertEquals(0, robotTime.m_lastRobotTime); + assertEquals(0, robotTime.m_frameNumber); + lastTime = robotTime.m_robotTime; + + // Act + wait(1); + robotTime.updateTimes(); + + // Assert + assertEquals(true, robotTime.m_deltaTime > 0); + assertEquals(true, robotTime.m_robotTime > 0); + assertEquals(lastTime, robotTime.m_lastRobotTime); + assertEquals(1, robotTime.m_frameNumber); + lastTime = robotTime.m_robotTime; + + // Act + wait(1); + robotTime.updateTimes(); + + // Assert + assertEquals(true, robotTime.m_deltaTime > 0); + assertEquals(true, robotTime.m_robotTime > 0); + assertEquals(lastTime, robotTime.m_lastRobotTime); + assertEquals(2, robotTime.m_frameNumber); + } + + @Test + public void testMatchTime() { + // Arrange + long lastTime; + + // Assert + assertEquals(0, robotTime.m_matchTime); + assertEquals(0, robotTime.m_lastMatchTime); + lastTime = robotTime.m_matchTime; + + // Act + robotTime.startMatchTime(); + wait(1); + robotTime.updateTimes(); + + // Assert + assertEquals(true, robotTime.m_matchTime > 0); + assertEquals(lastTime, robotTime.m_lastMatchTime); + lastTime = robotTime.m_matchTime; + + // Act + wait(1); + robotTime.updateTimes(); + robotTime.endMatchTime(); + + // Assert + assertEquals(0, robotTime.m_matchTime); + assertEquals(lastTime, robotTime.m_lastMatchTime); + lastTime = robotTime.m_matchTime; + + // Act + wait(1); + robotTime.updateTimes(); + + // Assert + assertEquals(0, robotTime.m_matchTime); + assertEquals(lastTime, robotTime.m_lastMatchTime); + } + + private void wait(int millis) { + try { + Thread.sleep(millis); + } catch (Exception e) {} + } +} diff --git a/vendordeps/NavX.json b/vendordeps/NavX.json new file mode 100644 index 0000000..33d81f6 --- /dev/null +++ b/vendordeps/NavX.json @@ -0,0 +1,39 @@ +{ + "fileName": "NavX.json", + "name": "KauaiLabs_navX_FRC", + "version": "2023.0.4", + "uuid": "cb311d09-36e9-4143-a032-55bb2b94443b", + "mavenUrls": [ + "https://dev.studica.com/maven/release/2023/" + ], + "jsonUrl": "https://dev.studica.com/releases/2023/NavX.json", + "javaDependencies": [ + { + "groupId": "com.kauailabs.navx.frc", + "artifactId": "navx-frc-java", + "version": "2023.0.4" + } + ], + "jniDependencies": [], + "cppDependencies": [ + { + "groupId": "com.kauailabs.navx.frc", + "artifactId": "navx-frc-cpp", + "version": "2023.0.4", + "headerClassifier": "headers", + "sourcesClassifier": "sources", + "sharedLibrary": false, + "libName": "navx_frc", + "skipInvalidPlatforms": true, + "binaryPlatforms": [ + "linuxathena", + "linuxraspbian", + "linuxarm32", + "linuxarm64", + "linuxx86-64", + "osxuniversal", + "windowsx86-64" + ] + } + ] +} \ No newline at end of file diff --git a/vendordeps/Phoenix.json b/vendordeps/Phoenix.json index f8d42a4..614dc3a 100644 --- a/vendordeps/Phoenix.json +++ b/vendordeps/Phoenix.json @@ -1,180 +1,423 @@ { "fileName": "Phoenix.json", - "name": "CTRE-Phoenix", - "version": "5.17.3", + "name": "CTRE-Phoenix (v5)", + "version": "5.31.0+23.2.2", + "frcYear": 2023, "uuid": "ab676553-b602-441f-a38d-f1296eff6537", "mavenUrls": [ - "http://devsite.ctr-electronics.com/maven/release/" + "https://maven.ctr-electronics.com/release/" ], - "jsonUrl": "http://devsite.ctr-electronics.com/maven/release/com/ctre/phoenix/Phoenix-latest.json", + "jsonUrl": "https://maven.ctr-electronics.com/release/com/ctre/phoenix/Phoenix5-frc2023-latest.json", "javaDependencies": [ { "groupId": "com.ctre.phoenix", "artifactId": "api-java", - "version": "5.17.3" + "version": "5.31.0" }, { "groupId": "com.ctre.phoenix", "artifactId": "wpiapi-java", - "version": "5.17.3" + "version": "5.31.0" } ], "jniDependencies": [ { "groupId": "com.ctre.phoenix", "artifactId": "cci", - "version": "5.17.3", + "version": "5.31.0", "isJar": false, "skipInvalidPlatforms": true, "validPlatforms": [ - "linuxathena", "windowsx86-64", - "linuxx86-64" - ] + "linuxx86-64", + "linuxathena" + ], + "simMode": "hwsim" }, { - "groupId": "com.ctre.phoenix", - "artifactId": "diagnostics", - "version": "5.17.3", + "groupId": "com.ctre.phoenix.sim", + "artifactId": "cci-sim", + "version": "5.31.0", "isJar": false, "skipInvalidPlatforms": true, "validPlatforms": [ - "linuxathena", "windowsx86-64", - "linuxx86-64" - ] + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" }, { - "groupId": "com.ctre.phoenix", - "artifactId": "canutils", - "version": "5.17.3", + "groupId": "com.ctre.phoenix6", + "artifactId": "tools", + "version": "23.2.2", "isJar": false, "skipInvalidPlatforms": true, "validPlatforms": [ "windowsx86-64", - "linuxx86-64" - ] + "linuxx86-64", + "linuxathena" + ], + "simMode": "hwsim" }, { - "groupId": "com.ctre.phoenix", - "artifactId": "platform-stub", - "version": "5.17.3", + "groupId": "com.ctre.phoenix6.sim", + "artifactId": "tools-sim", + "version": "23.2.2", "isJar": false, "skipInvalidPlatforms": true, "validPlatforms": [ "windowsx86-64", - "linuxx86-64" - ] + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" }, { - "groupId": "com.ctre.phoenix", - "artifactId": "core", - "version": "5.17.3", + "groupId": "com.ctre.phoenix6.sim", + "artifactId": "simTalonSRX", + "version": "23.2.2", "isJar": false, "skipInvalidPlatforms": true, "validPlatforms": [ - "linuxathena", "windowsx86-64", - "linuxx86-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.17.3", + "version": "5.31.0", "libName": "CTRE_Phoenix_WPI", "headerClassifier": "headers", - "sharedLibrary": false, + "sharedLibrary": true, "skipInvalidPlatforms": true, "binaryPlatforms": [ - "linuxathena", "windowsx86-64", - "linuxx86-64" - ] + "linuxx86-64", + "linuxathena" + ], + "simMode": "hwsim" }, { "groupId": "com.ctre.phoenix", "artifactId": "api-cpp", - "version": "5.17.3", + "version": "5.31.0", "libName": "CTRE_Phoenix", "headerClassifier": "headers", - "sharedLibrary": false, + "sharedLibrary": true, "skipInvalidPlatforms": true, "binaryPlatforms": [ - "linuxathena", "windowsx86-64", - "linuxx86-64" - ] + "linuxx86-64", + "linuxathena" + ], + "simMode": "hwsim" }, { "groupId": "com.ctre.phoenix", "artifactId": "cci", - "version": "5.17.3", + "version": "5.31.0", "libName": "CTRE_PhoenixCCI", "headerClassifier": "headers", - "sharedLibrary": false, + "sharedLibrary": true, "skipInvalidPlatforms": true, "binaryPlatforms": [ - "linuxathena", "windowsx86-64", - "linuxx86-64" - ] + "linuxx86-64", + "linuxathena" + ], + "simMode": "hwsim" }, { - "groupId": "com.ctre.phoenix", - "artifactId": "diagnostics", - "version": "5.17.3", - "libName": "CTRE_PhoenixDiagnostics", + "groupId": "com.ctre.phoenix6", + "artifactId": "tools", + "version": "23.2.2", + "libName": "CTRE_PhoenixTools", "headerClassifier": "headers", - "sharedLibrary": false, + "sharedLibrary": true, "skipInvalidPlatforms": true, "binaryPlatforms": [ - "linuxathena", "windowsx86-64", - "linuxx86-64" - ] + "linuxx86-64", + "linuxathena" + ], + "simMode": "hwsim" }, { - "groupId": "com.ctre.phoenix", - "artifactId": "canutils", - "version": "5.17.3", - "libName": "CTRE_PhoenixCanutils", + "groupId": "com.ctre.phoenix.sim", + "artifactId": "wpiapi-cpp-sim", + "version": "5.31.0", + "libName": "CTRE_Phoenix_WPISim", "headerClassifier": "headers", - "sharedLibrary": false, + "sharedLibrary": true, "skipInvalidPlatforms": true, "binaryPlatforms": [ "windowsx86-64", - "linuxx86-64" - ] + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" }, { - "groupId": "com.ctre.phoenix", - "artifactId": "platform-stub", - "version": "5.17.3", - "libName": "CTRE_PhoenixPlatform", + "groupId": "com.ctre.phoenix.sim", + "artifactId": "api-cpp-sim", + "version": "5.31.0", + "libName": "CTRE_PhoenixSim", "headerClassifier": "headers", - "sharedLibrary": false, + "sharedLibrary": true, "skipInvalidPlatforms": true, "binaryPlatforms": [ "windowsx86-64", - "linuxx86-64" - ] + "linuxx86-64", + "osxuniversal" + ], + "simMode": "swsim" }, { - "groupId": "com.ctre.phoenix", - "artifactId": "core", - "version": "5.17.3", - "libName": "CTRE_PhoenixCore", + "groupId": "com.ctre.phoenix.sim", + "artifactId": "cci-sim", + "version": "5.31.0", + "libName": "CTRE_PhoenixCCISim", "headerClassifier": "headers", - "sharedLibrary": false, + "sharedLibrary": true, "skipInvalidPlatforms": true, "binaryPlatforms": [ - "linuxathena", "windowsx86-64", - "linuxx86-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/WPILibNewCommands.json b/vendordeps/WPILibNewCommands.json index 83de291..bd535bf 100644 --- a/vendordeps/WPILibNewCommands.json +++ b/vendordeps/WPILibNewCommands.json @@ -1,37 +1,37 @@ { - "fileName": "WPILibNewCommands.json", - "name": "WPILib-New-Commands", - "version": "2020.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", - "linuxraspbian", - "linuxaarch64bionic", - "windowsx86-64", - "windowsx86", - "linuxx86-64", - "osxx86-64" - ] - } - ] -} \ No newline at end of file + "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" + ] + } + ] +} From 5e72e116fe90edeb254e9f7a3ffe92467eb03344 Mon Sep 17 00:00:00 2001 From: Abhishrek05 <90010729+Abhishrek05@users.noreply.github.com> Date: Fri, 5 Jan 2024 13:58:24 -0700 Subject: [PATCH 4/4] Worky 2 --- .../robot/subsystems/LEDSubsystemTest.java | 59 ------ .../frc4388/utility/RobotGyroUtilityTest.java | 184 ------------------ .../frc4388/utility/RobotTimeUtilityTest.java | 104 ---------- 3 files changed, 347 deletions(-) delete mode 100644 src/test/java/frc4388/robot/subsystems/LEDSubsystemTest.java delete mode 100644 src/test/java/frc4388/utility/RobotGyroUtilityTest.java delete mode 100644 src/test/java/frc4388/utility/RobotTimeUtilityTest.java diff --git a/src/test/java/frc4388/robot/subsystems/LEDSubsystemTest.java b/src/test/java/frc4388/robot/subsystems/LEDSubsystemTest.java deleted file mode 100644 index 8fcbf53..0000000 --- a/src/test/java/frc4388/robot/subsystems/LEDSubsystemTest.java +++ /dev/null @@ -1,59 +0,0 @@ -/*----------------------------------------------------------------------------*/ -/* Copyright (c) 2018-2019 FIRST. All Rights Reserved. */ -/* Open Source Software - may be modified and shared by FRC teams. The code */ -/* must be accompanied by the FIRST BSD license file in the root directory of */ -/* the project. */ -/*----------------------------------------------------------------------------*/ - -package frc4388.robot.subsystems; - -import static org.junit.Assert.assertEquals; -import static org.mockito.Mockito.mock; - -import org.junit.Test; - -import edu.wpi.first.wpilibj.*; -import frc4388.robot.Constants.LEDConstants; -import frc4388.utility.LEDPatterns; - -/** - * Add your docs here. - */ -public class LEDSubsystemTest { - @Test - public void testConstructor() { - // Arrange - Spark ledController = mock(Spark.class); - - // Act - LED led = new LED(ledController); - - // Assert - assertEquals(LEDConstants.DEFAULT_PATTERN.getValue(), led.getPattern().getValue(), 0.0001); - } - - @Test - public void testPatterns() { - // Arrange - Spark ledController = mock(Spark.class); - LED led = new LED(ledController); - - // Act - led.setPattern(LEDPatterns.RAINBOW_RAINBOW); - - // Assert - assertEquals(LEDPatterns.RAINBOW_RAINBOW.getValue(), led.getPattern().getValue(), 0.0001); - - // Act - led.setPattern(LEDPatterns.BLUE_BREATH); - - // Assert - assertEquals(LEDPatterns.BLUE_BREATH.getValue(), led.getPattern().getValue(), 0.0001); - - // Act - led.setPattern(LEDPatterns.SOLID_BLACK); - - // Assert - assertEquals(LEDPatterns.SOLID_BLACK.getValue(), led.getPattern().getValue(), 0.0001); - } -} diff --git a/src/test/java/frc4388/utility/RobotGyroUtilityTest.java b/src/test/java/frc4388/utility/RobotGyroUtilityTest.java deleted file mode 100644 index 8c0b1e5..0000000 --- a/src/test/java/frc4388/utility/RobotGyroUtilityTest.java +++ /dev/null @@ -1,184 +0,0 @@ -/*----------------------------------------------------------------------------*/ -/* Copyright (c) 2018-2019 FIRST. All Rights Reserved. */ -/* Open Source Software - may be modified and shared by FRC teams. The code */ -/* must be accompanied by the FIRST BSD license file in the root directory of */ -/* the project. */ -/*----------------------------------------------------------------------------*/ - -package frc4388.utility; - -import static org.junit.Assert.*; -import static org.mockito.Mockito.*; - -import com.kauailabs.navx.frc.AHRS; - -import org.junit.*; - -import frc4388.mocks.MockPigeonIMU; -import frc4388.robot.Constants.DriveConstants; - -/** - * Add your docs here. - */ -public class RobotGyroUtilityTest { - // TODO UNTESTED: most functions for NavX - - private RobotGyro gyroPigeon; - private RobotGyro gyroNavX; - - @Test - public void testConstructor() { - // Arrange - MockPigeonIMU pigeon = new MockPigeonIMU(DriveConstants.DRIVE_PIGEON_ID); - AHRS navX = mock(AHRS.class); - gyroPigeon = new RobotGyro(pigeon); - gyroNavX = new RobotGyro(navX); - - // Assert - assertEquals(true, gyroPigeon.m_isGyroAPigeon); - assertEquals(pigeon, gyroPigeon.getPigeon()); - assertEquals(null, gyroPigeon.getNavX()); - assertEquals(false, gyroNavX.m_isGyroAPigeon); - assertEquals(navX, gyroNavX.getNavX()); - assertEquals(null, gyroNavX.getPigeon()); - } - - @Test - public void testHeadingPigeon() { - // Arrange - MockPigeonIMU pigeon = new MockPigeonIMU(DriveConstants.DRIVE_PIGEON_ID); - gyroPigeon = new RobotGyro(pigeon); - - // Act & Assert - assertEquals(-90, gyroPigeon.getHeading(270), 0.0001); - assertEquals(-45, gyroPigeon.getHeading(315), 0.0001); - assertEquals(-60, gyroPigeon.getHeading(-60), 0.0001); - assertEquals(30, gyroPigeon.getHeading(30), 0.0001); - assertEquals(0, gyroPigeon.getHeading(0), 0.0001); - assertEquals(180, gyroPigeon.getHeading(180), 0.0001); - assertEquals(-180, gyroPigeon.getHeading(-180), 0.0001); - assertEquals(97, gyroPigeon.getHeading(1537), 0.0001); - assertEquals(99, gyroPigeon.getHeading(-2781), 0.0001); - } - - @Test - public void testYawPitchRollPigeon() { - // Arrange - MockPigeonIMU pigeon = new MockPigeonIMU(DriveConstants.DRIVE_PIGEON_ID); - gyroPigeon = new RobotGyro(pigeon); - - // Assert - assertEquals(0, gyroPigeon.getAngle(), 0.0001); - - // Act - pigeon.setYaw(40); - - // Assert - assertEquals(40, gyroPigeon.getAngle(), 0.0001); - - // Act - gyroPigeon.reset(); - - // Assert - assertEquals(0, gyroPigeon.getAngle(), 0.0001); - - // Act - pigeon.setYaw(-1457); - pigeon.setCurrentPitch(100); - pigeon.setCurrentRoll(100); - - // Assert - assertEquals(-1457, gyroPigeon.getAngle(), 0.0001); - assertEquals(90, gyroPigeon.getPitch(), 0.0001); - assertEquals(90, gyroPigeon.getRoll(), 0.0001); - - // Act - pigeon.setCurrentPitch(45); - pigeon.setCurrentRoll(45); - - // Assert - assertEquals(45, gyroPigeon.getPitch(), 0.0001); - assertEquals(45, gyroPigeon.getRoll(), 0.0001); - - // Act - pigeon.setCurrentPitch(0); - pigeon.setCurrentRoll(0); - - // Assert - assertEquals(0, gyroPigeon.getPitch(), 0.0001); - assertEquals(0, gyroPigeon.getRoll(), 0.0001); - - // Act - pigeon.setCurrentPitch(-60); - pigeon.setCurrentRoll(-60); - - // Assert - assertEquals(-60, gyroPigeon.getPitch(), 0.0001); - assertEquals(-60, gyroPigeon.getRoll(), 0.0001); - - // Act - pigeon.setCurrentPitch(-90); - pigeon.setCurrentRoll(-90); - - // Assert - assertEquals(-90, gyroPigeon.getPitch(), 0.0001); - assertEquals(-90, gyroPigeon.getRoll(), 0.0001); - - // Act - pigeon.setCurrentPitch(-100); - pigeon.setCurrentRoll(-100); - - // Assert - assertEquals(-90, gyroPigeon.getPitch(), 0.0001); - assertEquals(-90, gyroPigeon.getRoll(), 0.0001); - } - - @Test - public void testRatesPigeon() { - // Arrange - MockPigeonIMU pigeon = new MockPigeonIMU(DriveConstants.DRIVE_PIGEON_ID); - gyroPigeon = new RobotGyro(pigeon); - RobotTime robotTime = RobotTime.getInstance(); - gyroPigeon.updatePigeonDeltas(); - - // Act - robotTime.m_deltaTime = 5; - pigeon.setYaw(0); - gyroPigeon.updatePigeonDeltas(); - - // Assert - assertEquals(0, gyroPigeon.getRate(), 1); - - // Act - robotTime.m_deltaTime = 5; - pigeon.setYaw(90); - gyroPigeon.updatePigeonDeltas(); - - // Assert - assertEquals(18000, gyroPigeon.getRate(), 0.001); - - // Act - robotTime.m_deltaTime = 5; - pigeon.setYaw(90); - gyroPigeon.updatePigeonDeltas(); - - // Assert - assertEquals(0, gyroPigeon.getRate(), 0.001); - - // Act - robotTime.m_deltaTime = 3; - pigeon.setYaw(-30); - gyroPigeon.updatePigeonDeltas(); - - // Assert - assertEquals(-40000, gyroPigeon.getRate(), 0.001); - - // Act - robotTime.m_deltaTime = 6; - pigeon.setYaw(690); - gyroPigeon.updatePigeonDeltas(); - - // Assert - assertEquals(120000, gyroPigeon.getRate(), 0.001); - } -} diff --git a/src/test/java/frc4388/utility/RobotTimeUtilityTest.java b/src/test/java/frc4388/utility/RobotTimeUtilityTest.java deleted file mode 100644 index 2c31a34..0000000 --- a/src/test/java/frc4388/utility/RobotTimeUtilityTest.java +++ /dev/null @@ -1,104 +0,0 @@ -/*----------------------------------------------------------------------------*/ -/* Copyright (c) 2018-2019 FIRST. All Rights Reserved. */ -/* Open Source Software - may be modified and shared by FRC teams. The code */ -/* must be accompanied by the FIRST BSD license file in the root directory of */ -/* the project. */ -/*----------------------------------------------------------------------------*/ - -package frc4388.utility; - -import static org.junit.Assert.*; - -import org.junit.*; - -/** - * Add your docs here. - */ -public class RobotTimeUtilityTest { - RobotTime robotTime = RobotTime.getInstance(); - - @Test - public void testUpdateTimes() { - // Arrange - long lastTime; - robotTime.m_deltaTime = 0; - robotTime.m_robotTime = 0; - robotTime.m_lastRobotTime = 0; - robotTime.m_frameNumber = 0; - robotTime.endMatchTime(); - robotTime.m_lastMatchTime = 0; - - // Assert - assertEquals(0, robotTime.m_deltaTime); - assertEquals(0, robotTime.m_robotTime); - assertEquals(0, robotTime.m_lastRobotTime); - assertEquals(0, robotTime.m_frameNumber); - lastTime = robotTime.m_robotTime; - - // Act - wait(1); - robotTime.updateTimes(); - - // Assert - assertEquals(true, robotTime.m_deltaTime > 0); - assertEquals(true, robotTime.m_robotTime > 0); - assertEquals(lastTime, robotTime.m_lastRobotTime); - assertEquals(1, robotTime.m_frameNumber); - lastTime = robotTime.m_robotTime; - - // Act - wait(1); - robotTime.updateTimes(); - - // Assert - assertEquals(true, robotTime.m_deltaTime > 0); - assertEquals(true, robotTime.m_robotTime > 0); - assertEquals(lastTime, robotTime.m_lastRobotTime); - assertEquals(2, robotTime.m_frameNumber); - } - - @Test - public void testMatchTime() { - // Arrange - long lastTime; - - // Assert - assertEquals(0, robotTime.m_matchTime); - assertEquals(0, robotTime.m_lastMatchTime); - lastTime = robotTime.m_matchTime; - - // Act - robotTime.startMatchTime(); - wait(1); - robotTime.updateTimes(); - - // Assert - assertEquals(true, robotTime.m_matchTime > 0); - assertEquals(lastTime, robotTime.m_lastMatchTime); - lastTime = robotTime.m_matchTime; - - // Act - wait(1); - robotTime.updateTimes(); - robotTime.endMatchTime(); - - // Assert - assertEquals(0, robotTime.m_matchTime); - assertEquals(lastTime, robotTime.m_lastMatchTime); - lastTime = robotTime.m_matchTime; - - // Act - wait(1); - robotTime.updateTimes(); - - // Assert - assertEquals(0, robotTime.m_matchTime); - assertEquals(lastTime, robotTime.m_lastMatchTime); - } - - private void wait(int millis) { - try { - Thread.sleep(millis); - } catch (Exception e) {} - } -}