YAGSL

https://github.com/yet-another-software-suite/yagsl
Admin
Yet Another Generic Swerve Library (YAGSL) is an easy-to-use implementation of a generic swerve...
Tokens:10,670
Snippets:113
Trust Score:6.1
License:LGPL-2.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Get Raw Chassis Speeds from Velocity Inputs

Source: https://context7.com/yet-another-software-suite/yagsl/llms.txt

Directly calculates raw chassis speeds from provided X speed, Y speed, and angular velocity inputs in meters per second and radians per second.

```java
return swerveController.getRawTargetSpeeds(xSpeedMPS, ySpeedMPS, omegaRadPerSec);
```

--------------------------------

### Vendor URL for YAGSL Installation

Source: https://github.com/yet-another-software-suite/yagsl/blob/main/examples/clock_drive_drivebase/README.md

This is the vendor URL to add YAGSL to your FRC project's vendor dependencies.

```text
https://broncbotz3481.github.io/YAGSL-Lib/yagsl/yagsl.json
```

--------------------------------

### Get Current Robot Pose

Source: https://context7.com/yet-another-software-suite/yagsl/llms.txt

Retrieves the current estimated robot pose from the SwerveDrive object. This is the primary method for obtaining the robot's position and orientation on the field.

```java
import edu.wpi.first.math.Matrix;
import edu.wpi.first.math.VecBuilder;
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.numbers.N1;
import edu.wpi.first.math.numbers.N3;
import edu.wpi.first.wpilibj.Timer;
import swervelib.SwerveDrive;

public class OdometryManager {
    private final SwerveDrive swerveDrive;

    public OdometryManager(SwerveDrive drive) {
        this.swerveDrive = drive;
    }

    // Get current estimated robot pose
    public Pose2d getCurrentPose() {
        return swerveDrive.getPose();
    }

    // Get current heading from odometry (preferred over raw gyro)
    public Rotation2d getHeading() {
        return swerveDrive.getOdometryHeading();
    }

    // Reset odometry to a known pose
    public void resetOdometry(Pose2d newPose) {
        swerveDrive.resetOdometry(newPose);
    }

    // Zero the gyro (sets current heading to 0)
    public void zeroGyro() {
        swerveDrive.zeroGyro();
    }

    // Add vision measurement with standard deviations
    public void addVisionMeasurement(Pose2d visionPose, double timestampSeconds,
                                     double xStdDev, double yStdDev, double thetaStdDev) {
        Matrix<N3, N1> stdDevs = VecBuilder.fill(xStdDev, yStdDev, thetaStdDev);
        swerveDrive.addVisionMeasurement(visionPose, timestampSeconds, stdDevs);
    }

    // Add vision measurement with default standard deviations
    public void addVisionMeasurement(Pose2d visionPose) {
        swerveDrive.addVisionMeasurement(visionPose, Timer.getFPGATimestamp());
    }

    // Get field-relative velocity
    public ChassisSpeeds getFieldVelocity() {
        return swerveDrive.getFieldVelocity();
    }

    // Get robot-relative velocity
    public ChassisSpeeds getRobotVelocity() {
        return swerveDrive.getRobotVelocity();
    }

    // Get raw gyro values
    public Rotation2d getYaw() { return swerveDrive.getYaw(); }
    public Rotation2d getPitch() { return swerveDrive.getPitch(); }
    public Rotation2d getRoll() { return swerveDrive.getRoll(); }
}

```

--------------------------------

### Configure SwerveInputStream Controller Bindings

Source: https://context7.com/yet-another-software-suite/yagsl/llms.txt

Demonstrates creating angular velocity, heading-controlled, and target-aiming input streams for a swerve drive system using a fluent builder pattern.

```java
import edu.wpi.first.wpilibj2.command.Command;
import edu.wpi.first.wpilibj2.command.button.CommandXboxController;
import edu.wpi.first.math.geometry.Pose2d;
import edu.wpi.first.math.geometry.Rotation2d;
import edu.wpi.first.math.geometry.Translation2d;
import swervelib.SwerveInputStream;
import swervelib.SwerveDrive;

public class ControllerBindings {
    private final CommandXboxController controller = new CommandXboxController(0);
    private final SwerveDrive swerveDrive;

    // Angular velocity control (rotation via right stick X)
    public SwerveInputStream createAngularVelocityStream() {
        return SwerveInputStream.of(swerveDrive,
                                    () -> -controller.getLeftY(),  // Forward/back
                                    () -> -controller.getLeftX())  // Left/right
            .withControllerRotationAxis(controller::getRightX)     // Rotation
            .deadband(0.1)                                         // 10% deadband
            .scaleTranslation(0.8)                                 // 80% max speed
            .scaleRotation(0.7)                                    // 70% max rotation
            .allianceRelativeControl(true)                         // Flip for red alliance
            .cubeTranslationControllerAxis(true);                  // Cubic response curve
    }

    // Heading control (point robot using right stick angle)
    public SwerveInputStream createHeadingStream() {
        return SwerveInputStream.of(swerveDrive,
                                    () -> -controller.getLeftY(),
                                    () -> -controller.getLeftX())
            .withControllerHeadingAxis(controller::getRightX, controller::getRightY)
            .deadband(0.1)
            .scaleTranslation(0.8)
            .allianceRelativeControl(true)
            .headingWhile(true);  // Enable heading mode
    }

    // Aim at target while driving
    public SwerveInputStream createAimStream(Pose2d targetPose) {
        return SwerveInputStream.of(swerveDrive,
                                    () -> -controller.getLeftY(),
                                    () -> -controller.getLeftX())
            .withControllerRotationAxis(controller::getRightX)
            .deadband(0.1)
            .scaleTranslation(0.8)
            .allianceRelativeControl(true)
            .aim(targetPose)                                       // Target to aim at
            .aimWhile(() -> controller.rightBumper().getAsBoolean()); // Aim when held
    }

    // Create drive command from input stream
    public Command createDriveCommand(SwerveInputStream inputStream) {
        return swerveDrive.driveFieldOriented(inputStream);
    }
}
```

--------------------------------

### Initialize SwerveDrive from JSON in Java

Source: https://context7.com/yet-another-software-suite/yagsl/llms.txt

Uses SwerveParser to load configuration files from the deploy directory and initialize the SwerveDrive object within a subsystem.

```java
import java.io.File;
import edu.wpi.first.wpilibj.Filesystem;
import edu.wpi.first.math.geometry.Pose2d;
import edu.wpi.first.math.geometry.Translation2d;
import edu.wpi.first.math.geometry.Rotation2d;
import edu.wpi.first.math.util.Units;
import swervelib.parser.SwerveParser;
import swervelib.SwerveDrive;
import swervelib.telemetry.SwerveDriveTelemetry;
import swervelib.telemetry.SwerveDriveTelemetry.TelemetryVerbosity;

public class SwerveSubsystem {
    private final SwerveDrive swerveDrive;
    private static final double MAX_SPEED = Units.feetToMeters(14.5); // Max speed in m/s

    public SwerveSubsystem() {
        // Set telemetry verbosity before creating SwerveDrive
        SwerveDriveTelemetry.verbosity = TelemetryVerbosity.HIGH;

        // Parse JSON configuration from deploy directory
        File swerveConfigDir = new File(Filesystem.getDeployDirectory(), "swerve/neo");

        try {
            // Create SwerveDrive with max speed and optional starting pose
            Pose2d startingPose = new Pose2d(
                new Translation2d(1, 4),
                Rotation2d.fromDegrees(0)
            );
            swerveDrive = new SwerveParser(swerveConfigDir).createSwerveDrive(MAX_SPEED, startingPose);

            // Configure drive behavior
            swerveDrive.setHeadingCorrection(false);
            swerveDrive.setCosineCompensator(true);
            swerveDrive.setAngularVelocityCompensation(true, true, 0.1);
            swerveDrive.setModuleEncoderAutoSynchronize(false, 1);
        } catch (Exception e) {
            throw new RuntimeException("Failed to initialize swerve drive", e);
        }
    }

    public SwerveDrive getSwerveDrive() {
        return swerveDrive;
    }
}
```

--------------------------------

### Configure PathPlanner AutoBuilder in YAGSL

Source: https://context7.com/yet-another-software-suite/yagsl/llms.txt

Initializes AutoBuilder with pose suppliers, odometry resets, and holonomic drive controllers. Requires a valid RobotConfig loaded from GUI settings.

```java
import com.pathplanner.lib.auto.AutoBuilder;
import com.pathplanner.lib.config.PIDConstants;
import com.pathplanner.lib.config.RobotConfig;
import com.pathplanner.lib.controllers.PPHolonomicDriveController;
import com.pathplanner.lib.path.PathConstraints;
import edu.wpi.first.math.geometry.Pose2d;
import edu.wpi.first.math.util.Units;
import edu.wpi.first.wpilibj.DriverStation;
import edu.wpi.first.wpilibj2.command.Command;
import edu.wpi.first.wpilibj2.command.SubsystemBase;
import swervelib.SwerveDrive;

public class AutonomousSetup extends SubsystemBase {
    private final SwerveDrive swerveDrive;

    public void setupPathPlanner() {
        try {
            RobotConfig config = RobotConfig.fromGUISettings();

            AutoBuilder.configure(
                swerveDrive::getPose,                    // Pose supplier
                swerveDrive::resetOdometry,             // Pose reset consumer
                swerveDrive::getRobotVelocity,          // Robot-relative ChassisSpeeds supplier
                (speeds, feedforwards) -> {
                    // Drive the robot with feedforwards
                    swerveDrive.drive(
                        speeds,
                        swerveDrive.kinematics.toSwerveModuleStates(speeds),
                        feedforwards.linearForces()
                    );
                },
                new PPHolonomicDriveController(
                    new PIDConstants(5.0, 0.0, 0.0),     // Translation PID
                    new PIDConstants(5.0, 0.0, 0.0)      // Rotation PID
                ),
                config,
                () -> {
                    // Flip path for red alliance
                    var alliance = DriverStation.getAlliance();
                    return alliance.isPresent() && alliance.get() == DriverStation.Alliance.Red;
                },
                this
            );
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // Pathfind to a target pose
    public Command driveToPose(Pose2d targetPose) {
        PathConstraints constraints = new PathConstraints(
            swerveDrive.getMaximumChassisVelocity(),
            4.0,  // Max acceleration m/s^2
            swerveDrive.getMaximumChassisAngularVelocity(),
            Units.degreesToRadians(720)  // Max angular acceleration
        );

        return AutoBuilder.pathfindToPose(
            targetPose,
            constraints,
            edu.wpi.first.units.Units.MetersPerSecond.of(0)  // End velocity
        );
    }
}
```

--------------------------------

### Initialize SwerveController with Slew Rate Limiters

Source: https://context7.com/yet-another-software-suite/yagsl/llms.txt

Initializes the SwerveController and adds slew rate limiters for X, Y, and angular acceleration to ensure smooth robot movements. Requires `SwerveDrive` instance.

```java
import edu.wpi.first.math.filter.SlewRateLimiter;
import edu.wpi.first.math.kinematics.ChassisSpeeds;
import swervelib.SwerveController;
import swervelib.SwerveDrive;

public class HeadingControl {
    private final SwerveDrive swerveDrive;
    private final SwerveController swerveController;
    private final double maxSpeed = 4.5; // m/s

    public HeadingControl(SwerveDrive drive) {
        this.swerveDrive = drive;
        this.swerveController = drive.getSwerveController();

        // Add slew rate limiters for smooth acceleration
        swerveController.addSlewRateLimiters(
            new SlewRateLimiter(3.0),  // X acceleration limit (m/s^2)
            new SlewRateLimiter(3.0),  // Y acceleration limit (m/s^2)
            new SlewRateLimiter(5.0)   // Angular acceleration limit (rad/s^2)
        );
    }

    // Get target speeds with heading joystick control
    public ChassisSpeeds getTargetSpeedsWithHeading(
            double xInput, double yInput,
            double headingX, double headingY) {

        double currentHeading = swerveDrive.getOdometryHeading().getRadians();

        return swerveController.getTargetSpeeds(
            xInput, yInput,           // Translation inputs [-1, 1]
            headingX, headingY,       // Heading joystick inputs [-1, 1]
            currentHeading,           // Current heading in radians
            maxSpeed                  // Maximum speed in m/s
        );
    }

    // Get target speeds with specific angle target
    public ChassisSpeeds getTargetSpeedsWithAngle(
            double xInput, double yInput, double targetAngleRadians) {

        double currentHeading = swerveDrive.getOdometryHeading().getRadians();

        return swerveController.getTargetSpeeds(
            xInput, yInput,
            targetAngleRadians,
            currentHeading,
            maxSpeed
        );
    }

    // Get raw chassis speeds from velocity inputs
    public ChassisSpeeds getRawTargetSpeeds(
            double xSpeedMPS, double ySpeedMPS, double omegaRadPerSec) {

        return swerveController.getRawTargetSpeeds(xSpeedMPS, ySpeedMPS, omegaRadPerSec);
    }

    // Calculate heading correction angular velocity
    public double calculateHeadingCorrection(double currentAngle, double targetAngle) {
        return swerveController.headingCalculate(currentAngle, targetAngle);
    }
}

```

--------------------------------

### Define Main SwerveDrive Configuration

Source: https://context7.com/yet-another-software-suite/yagsl/llms.txt

JSON schema for swervedrive.json defining IMU hardware and module file references.

```json
{
  "imu": {
    "type": "pigeon2",
    "id": 13,
    "canbus": "canivore"
  },
  "invertedIMU": true,
  "modules": [
    "frontleft.json",
    "frontright.json",
    "backleft.json",
    "backright.json"
  ]
}
```

--------------------------------

### Swerve Configuration File Structure

Source: https://github.com/yet-another-software-suite/yagsl/blob/main/examples/clock_drive_drivebase/README.md

This structure shows the expected organization of configuration files after unzipping the downloaded configuration. Ensure your files follow this layout for proper loading.

```text
deploy
└── swerve
    ├── controllerproperties.json
    ├── modules
    │	   ├── backleft.json
    │	   ├── backright.json
    │	   ├── frontleft.json
    │	   ├── frontright.json
    │	   ├── physicalproperties.json
    │	   └── pidfproperties.json
    └── swervedrive.json
```

--------------------------------

### Configure MapleSim Simulation Support

Source: https://context7.com/yet-another-software-suite/yagsl/llms.txt

Handles simulation-specific logic, including pose retrieval, field visualization, and adjusting odometry update periods for simulation environments.

```java
import edu.wpi.first.math.geometry.Pose2d;
import edu.wpi.first.wpilibj.smartdashboard.Field2d;
import swervelib.SwerveDrive;
import swervelib.telemetry.SwerveDriveTelemetry;
import swervelib.simulation.ironmaple.simulation.SimulatedArena;

public class SimulationSupport {
    private final SwerveDrive swerveDrive;
    private final Field2d field2d;

    public SimulationSupport(SwerveDrive drive) {
        this.swerveDrive = drive;
        this.field2d = swerveDrive.field;
    }

    // Check if running in simulation
    public boolean isSimulation() {
        return SwerveDriveTelemetry.isSimulation;
    }

    // Get actual simulated pose (different from estimated pose)
    public Pose2d getSimulatedPose() {
        return swerveDrive.getSimulationDriveTrainPose()
                         .orElse(swerveDrive.getPose());
    }

    // Access the maple-sim drive simulation
    public void configureSimulation() {
        swerveDrive.getMapleSimDrive().ifPresent(simDrive -> {
            // Configure simulation-specific settings
            // Add game pieces, obstacles, etc.
        });
    }

    // Get field visualization object
    public Field2d getField2d() {
        return field2d;
    }

    // Set odometry update period (faster for simulation)
    public void setSimulationOdometryPeriod() {
        if (SwerveDriveTelemetry.isSimulation) {
            swerveDrive.setOdometryPeriod(0.004);  // 4ms for simulation
        } else {
            swerveDrive.setOdometryPeriod(0.02);   // 20ms for real robot
        }
    }
}
```

--------------------------------

### Create SwerveDrive Object with Default Conversion Factors

Source: https://github.com/yet-another-software-suite/yagsl/blob/main/examples/clock_drive_drivebase/README.md

This Java code snippet demonstrates how to create a SwerveDrive object using the SwerveParser, specifying the directory for configuration files and the robot's maximum speed in meters per second. Ensure the 'swerve' directory is in the 'deploy' folder.

```java
import java.io.File;
import edu.wpi.first.wpilibj.Filesystem;
import swervelib.parser.SwerveParser;
import swervelib.SwerveDrive;
import edu.wpi.first.math.util.Units;


SwerveDrive swerveDrive=new SwerveParser(new File(Filesystem.getDeployDirectory(),"swerve")).createSwerveDrive(Units.feetToMeters(14.5));
```

--------------------------------

### Swerve Configuration File Structure

Source: https://github.com/yet-another-software-suite/yagsl/blob/main/examples/drivebase_with_PhotonVision/README.md

This is the expected directory structure for swerve configuration files after generating and unzipping them. Ensure your files follow this layout for proper loading.

```text
deploy
└── swerve
    ├── controllerproperties.json
    ├── modules
    │   ├── backleft.json
    │   ├── backright.json
    │   ├── frontleft.json
    │   ├── frontright.json
    │   ├── physicalproperties.json
    │   └── pidfproperties.json
    └── swervedrive.json
```

--------------------------------

### Field-Relative Drive with SwerveDrive.drive() (Java)

Source: https://context7.com/yet-another-software-suite/yagsl/llms.txt

Controls robot movement in a field-relative manner using translation velocity and rotation speed. Set isOpenLoop to true for open-loop control.

```java
import edu.wpi.first.math.geometry.Translation2d;
import edu.wpi.first.math.kinematics.ChassisSpeeds;
import swervelib.SwerveDrive;

public class DriveController {
    private final SwerveDrive swerveDrive;

    // Field-relative drive with joystick inputs
    public void driveFieldRelative(double xSpeed, double ySpeed, double rotationSpeed) {
        // xSpeed: forward/backward in m/s (positive = forward)
        // ySpeed: left/right in m/s (positive = left)
        // rotationSpeed: angular velocity in rad/s (positive = CCW)

        Translation2d translation = new Translation2d(xSpeed, ySpeed);
        boolean fieldRelative = true;
        boolean isOpenLoop = false; // Use closed-loop velocity control

        swerveDrive.drive(translation, rotationSpeed, fieldRelative, isOpenLoop);
    }

    // Robot-relative drive
    public void driveRobotRelative(double xSpeed, double ySpeed, double rotationSpeed) {
        Translation2d translation = new Translation2d(xSpeed, ySpeed);
        swerveDrive.drive(translation, rotationSpeed, false, false);
    }

    // Drive using ChassisSpeeds directly
    public void driveWithChassisSpeeds(ChassisSpeeds speeds) {
        // Robot-relative ChassisSpeeds
        swerveDrive.drive(speeds);
    }

    // Field-oriented drive with ChassisSpeeds
    public void driveFieldOriented(ChassisSpeeds fieldRelativeSpeeds) {
        swerveDrive.driveFieldOriented(fieldRelativeSpeeds);
    }

    // Drive with custom center of rotation
    public void driveAroundPoint(double xSpeed, double ySpeed, double rotationSpeed,
                                  Translation2d centerOfRotation) {
        Translation2d translation = new Translation2d(xSpeed, ySpeed);
        swerveDrive.drive(translation, rotationSpeed, true, false, centerOfRotation);
    }
}
```

--------------------------------

### Manage Swerve Modules and Drive Configuration

Source: https://context7.com/yet-another-software-suite/yagsl/llms.txt

Provides methods for accessing module states, configuring PIDF values, and controlling drivetrain behaviors like wheel locking and brake modes.

```java
import edu.wpi.first.math.kinematics.SwerveModulePosition;
import edu.wpi.first.math.kinematics.SwerveModuleState;
import swervelib.SwerveModule;
import swervelib.SwerveDrive;
import swervelib.parser.PIDFConfig;

public class ModuleManager {
    private final SwerveDrive swerveDrive;

    public ModuleManager(SwerveDrive drive) {
        this.swerveDrive = drive;
    }

    // Get all module states
    public SwerveModuleState[] getModuleStates() {
        return swerveDrive.getStates();
    }

    // Get all module positions
    public SwerveModulePosition[] getModulePositions() {
        return swerveDrive.getModulePositions();
    }

    // Access individual modules
    public void configureModules() {
        SwerveModule[] modules = swerveDrive.getModules();

        for (SwerveModule module : modules) {
            // Get module state
            SwerveModuleState state = module.getState();
            double velocity = state.speedMetersPerSecond;
            double angle = state.angle.getDegrees();

            // Get absolute encoder position
            double absolutePosition = module.getAbsolutePosition();

            // Configure PIDF values
            PIDFConfig drivePID = new PIDFConfig(0.1, 0, 0, 0);
            module.setDrivePIDF(drivePID);

            PIDFConfig anglePID = new PIDFConfig(0.01, 0, 0, 0);
            module.setAnglePIDF(anglePID);

            // Check for encoder issues
            boolean hasEncoderIssue = module.getAbsoluteEncoderReadIssue();
        }
    }

    // Lock wheels in X pattern to prevent movement
    public void lockWheels() {
        swerveDrive.lockPose();
    }

    // Set motor brake mode
    public void setBrakeMode(boolean brake) {
        swerveDrive.setMotorIdleMode(brake);
    }

    // Center all modules to 0 degrees
    public void centerModules() {
        for (SwerveModule module : swerveDrive.getModules()) {
            module.setAngle(0);
        }
    }

    // Enable/disable module state optimization
    public void setOptimization(boolean enabled) {
        swerveDrive.setModuleStateOptimization(enabled);
    }

    // Enable cosine compensator for better accuracy
    public void setCosineCompensator(boolean enabled) {
        swerveDrive.setCosineCompensator(enabled);
    }
}
```

--------------------------------

### Define Physical Module Properties

Source: https://context7.com/yet-another-software-suite/yagsl/llms.txt

JSON schema for physicalproperties.json defining gear ratios, wheel diameter, and current limits.

```json
{
  "conversionFactors": {
    "angle": {
      "gearRatio": 12.8,
      "factor": 0
    },
    "drive": {
      "gearRatio": 8.14,
      "diameter": 4,
      "factor": 0
    }
  },
  "currentLimit": {
    "drive": 40,
    "angle": 20
  },
  "rampRate": {
    "drive": 0.25,
    "angle": 0.25
  },
  "wheelGripCoefficientOfFriction": 1.19,
  "optimalVoltage": 12
}
```

--------------------------------

### YAGSL Configuration Directory Structure

Source: https://context7.com/yet-another-software-suite/yagsl/llms.txt

Required file layout for YAGSL JSON configuration files within the project deploy directory.

```text
deploy/
└── swerve/
    ├── controllerproperties.json    # Heading PID and joystick deadband
    ├── swervedrive.json             # IMU config and module file references
    └── modules/
        ├── pidfproperties.json      # Drive and angle motor PID values
        ├── physicalproperties.json  # Gear ratios, wheel size, current limits
        ├── frontleft.json           # Front left module hardware config
        ├── frontright.json          # Front right module hardware config
        ├── backleft.json            # Back left module hardware config
        └── backright.json           # Back right module hardware config
```

--------------------------------

### Create SwerveDrive Object with Custom Conversion Factors

Source: https://github.com/yet-another-software-suite/yagsl/blob/main/examples/clock_drive_drivebase/README.md

This Java code shows how to create a SwerveDrive object when custom drive and steering conversion factors are needed. This is useful if your swerve modules use different motors than the default configuration. The conversion factors are calculated using helper methods.

```java
double DriveConversionFactor = SwerveMath.calculateMetersPerRotation(Units.inchesToMeters(WHEEL_DIAMETER), GEAR_RATIO, ENCODER_RESOLUTION);
double SteeringConversionFactor = SwerveMath.calculateDegreesPerSteeringRotation(GEAR_RATIO, ENCODER_RESOLUTION);
SwerveDrive swerveDrive = new SwerveParser(directory).createSwerveDrive(maximumSpeed, SteeringConversionFactor, DriveConversionFactor);
```

--------------------------------

### Calculate Target Speeds with Heading Joystick Control

Source: https://context7.com/yet-another-software-suite/yagsl/llms.txt

Calculates target chassis speeds using translation inputs, heading joystick inputs, current robot heading, and maximum speed. Assumes inputs are normalized to [-1, 1].

```java
double currentHeading = swerveDrive.getOdometryHeading().getRadians();

return swerveController.getTargetSpeeds(
    xInput, yInput,           // Translation inputs [-1, 1]
    headingX, headingY,       // Heading joystick inputs [-1, 1]
    currentHeading,           // Current heading in radians
    maxSpeed                  // Maximum speed in m/s
);
```

--------------------------------

### Define YAGSL Configuration Directory Structure

Source: https://github.com/yet-another-software-suite/yagsl/blob/main/examples/drivebase_with_PathPlanner/README.md

The required directory structure for swerve drive configuration files within the project's deploy folder.

```text
deploy
└── swerve
    ├── controllerproperties.json
    ├── modules
    │   ├── backleft.json
    │   ├── backright.json
    │   ├── frontleft.json
    │   ├── frontright.json
    │   ├── physicalproperties.json
    │   └── pidfproperties.json
    └── swervedrive.json
```

--------------------------------

### Individual Swerve Module Configuration (JSON)

Source: https://context7.com/yet-another-software-suite/yagsl/llms.txt

Configuration for a single swerve module, specifying drive and angle motor types, IDs, CAN bus, encoder details, and inversion settings.

```json
{
  "drive": {
    "type": "sparkmax_neo",
    "id": 4,
    "canbus": null
  },
  "angle": {
    "type": "sparkmax_neo",
    "id": 3,
    "canbus": null
  },
  "encoder": {
    "type": "cancoder",
    "id": 9,
    "canbus": null
  },
  "inverted": {
    "drive": false,
    "angle": false
  },
  "absoluteEncoderOffset": -114.609,
  "location": {
    "front": 12,
    "left": 12
  }
}
```

--------------------------------

### Calculate Target Speeds with Specific Angle Target

Source: https://context7.com/yet-another-software-suite/yagsl/llms.txt

Calculates target chassis speeds using translation inputs, a specific target angle in radians, current robot heading, and maximum speed.

```java
double currentHeading = swerveDrive.getOdometryHeading().getRadians();

return swerveController.getTargetSpeeds(
    xInput, yInput,
    targetAngleRadians,
    currentHeading,
    maxSpeed
);
```

--------------------------------

### Calculate Drive Motor Conversion Factor

Source: https://context7.com/yet-another-software-suite/yagsl/llms.txt

Calculates the drive motor conversion factor in meters per rotation. Requires wheel diameter and drive gear ratio.

```java
import edu.wpi.first.math.controller.SimpleMotorFeedforward;
import edu.wpi.first.math.geometry.Translation2d;
import swervelib.math.SwerveMath;

public class ConversionFactors {

    // Calculate drive motor conversion factor (meters per rotation)
    public static double calculateDriveConversion() {
        double wheelDiameterMeters = 0.1016; // 4 inches in meters
        double driveGearRatio = 8.14;        // L1 MK4i ratio

        // Returns meters traveled per motor rotation
        return SwerveMath.calculateMetersPerRotation(wheelDiameterMeters, driveGearRatio);
    }

    // Calculate angle motor conversion factor (degrees per rotation)
    public static double calculateAngleConversion() {
        double angleGearRatio = 21.4286;  // MK4i steering ratio

        // Returns degrees of module rotation per motor rotation
        return SwerveMath.calculateDegreesPerSteeringRotation(angleGearRatio);
    }

    // Calculate maximum angular velocity
    public static double calculateMaxAngularVelocity() {
        double maxSpeedMPS = 4.5;
        double furthestModuleX = 0.3;  // meters from center
        double furthestModuleY = 0.3;  // meters from center

        // Returns max angular velocity in rad/s
        return SwerveMath.calculateMaxAngularVelocity(maxSpeedMPS, furthestModuleX, furthestModuleY);
    }

    // Create drive motor feedforward
    public static SimpleMotorFeedforward createDriveFeedforward() {
        double optimalVoltage = 12.0;
        double maxSpeedMPS = 4.5;
        double wheelGripCoefficient = 1.19;

        return SwerveMath.createDriveFeedforward(optimalVoltage, maxSpeedMPS, wheelGripCoefficient);
    }

    // Apply cubic transformation for smoother joystick control
    public static Translation2d applyJoystickCurve(double x, double y) {
        Translation2d rawInput = new Translation2d(x, y);
        return SwerveMath.cubeTranslation(rawInput);
    }

    // Scale translation by factor
    public static Translation2d scaleInput(double x, double y, double scalar) {
        Translation2d input = new Translation2d(x, y);
        return SwerveMath.scaleTranslation(input, scalar);
    }
}

```

--------------------------------

### Calculate Heading Correction Angular Velocity

Source: https://context7.com/yet-another-software-suite/yagsl/llms.txt

Calculates the necessary angular velocity to correct the robot's current heading towards a target angle using PID control.

```java
return swerveController.headingCalculate(currentAngle, targetAngle);
```
Tokens:
Raw