General Update

build.gradle

@@ -1,8 +1,8 @@
 plugins {
-    id "java"
+    id "java-library"
     id "maven-publish"
-    id "edu.wpi.first.GradleRIO" version "2024.3.2"
-    id "edu.wpi.first.WpilibTools" version "1.3.0"
+    id "edu.wpi.first.GradleRIO" version "2025.1.1-beta-1"
+    id "edu.wpi.first.WpilibTools" version "2.1.0"
 }
 
 java {
@@ -51,6 +51,7 @@ wpi.java.configureTestTasks(test)
 // Configure string concat to always inline compile
 tasks.withType(JavaCompile) {
     options.compilerArgs.add '-XDstringConcat=inline'
+    javadoc.options.addStringOption('Xdoclint:none', '-quiet')
 }
 
 task sourcesJar(type: Jar, dependsOn: classes) {

src/main/java/org/trigon/commands/ExecuteEndCommand.java

@@ -18,4 +18,4 @@ public ExecuteEndCommand(Runnable onExecute, Runnable onEnd, SubsystemBase... re
         super(() -> {
         }, onExecute, (interrupted) -> onEnd.run(), () -> false, requirements);
     }
-}
+}

src/main/java/org/trigon/hardware/BaseInputs.java

@@ -11,6 +11,11 @@ public abstract class BaseInputs implements LoggableInputs {
     private final String name;
     private double lastErrorTimestamp = 0;
 
+    /**
+     * Creates a new BaseInputs instance.
+     *
+     * @param name the name of the instance. Used for error messages
+     */
     public BaseInputs(String name) {
         this.name = name;
     }
@@ -20,6 +25,12 @@ public void fromLog(LogTable table) {
         latestTable = table;
     }
 
+    /**
+     * Gets a signal from the inputs.
+     *
+     * @param signalName the name of the signal
+     * @return the signal
+     */
     public double getSignal(String signalName) {
         if (latestTable == null) {
             if (shouldPrintError())
@@ -37,6 +48,13 @@ public double getSignal(String signalName) {
         return value.getDouble();
     }
 
+    /**
+     * Gets a threaded signal.
+     * Threaded signals use threading to process certain signals separately at a faster rate.
+     *
+     * @param signalName the name of the threaded signal
+     * @return the threaded signal
+     */
     public double[] getThreadedSignal(String signalName) {
         if (latestTable == null) {
             if (shouldPrintError())

src/main/java/org/trigon/hardware/RobotHardwareStats.java

@@ -1,40 +1,78 @@
 package org.trigon.hardware;
 
+/**
+ * A class that contains stats about the robot's hardware.
+ */
 public class RobotHardwareStats {
+    public static final double SUPPLY_VOLTAGE = 12;
     private static boolean IS_SIMULATION = false;
     private static boolean IS_REPLAY = false;
     private static double PERIODIC_TIME_SECONDS = 0.02;
 
+    /**
+     * Sets the current robot stats. This should be called in the robot's init method.
+     * If isReal is true both simulation and replay will be false, otherwise they will be set according to the replay type.
+     * We use this structure to avoid using static variables in the Robot class.
+     *
+     * @param isReal     whether the robot is real or a simulation. This should be taken from the Robot class
+     * @param replayType the type of replay
+     */
     public static void setCurrentRobotStats(boolean isReal, ReplayType replayType) {
         if (isReal || replayType.equals(ReplayType.NONE)) {
             IS_SIMULATION = !isReal;
             IS_REPLAY = false;
             return;
         }
-        
+
         IS_SIMULATION = replayType.equals(ReplayType.SIMULATION_REPLAY);
         IS_REPLAY = true;
     }
 
+    /**
+     * Sets how frequently the simulation is updated.
+     *
+     * @param periodicTimeSeconds the periodic time in seconds
+     */
     public static void setPeriodicTimeSeconds(double periodicTimeSeconds) {
         PERIODIC_TIME_SECONDS = periodicTimeSeconds;
     }
 
+    /**
+     * @return the periodic time in seconds set in {@link #setPeriodicTimeSeconds(double)}
+     */
     public static double getPeriodicTimeSeconds() {
         return PERIODIC_TIME_SECONDS;
     }
 
+    /**
+     * @return whether the robot is in replay mode or not
+     */
     public static boolean isReplay() {
         return IS_REPLAY;
     }
 
+    /**
+     * @return whether the robot is running in simulation or not
+     */
     public static boolean isSimulation() {
         return IS_SIMULATION;
     }
 
+    /**
+     * An enum that represents the type of replay.
+     */
     public enum ReplayType {
+        /**
+         * The robot is not in replay mode
+         */
         NONE,
+        /**
+         * The robot is in simulation replay mode
+         */
         SIMULATION_REPLAY,
+        /**
+         * The robot is in real replay mode
+         */
         REAL_REPLAY
     }
 }

src/main/java/org/trigon/hardware/SignalThreadBase.java

@@ -7,21 +7,41 @@
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.locks.ReentrantLock;
 
+/**
+ * A class that represents a base for a signal thread.
+ * Signal threads are specialized threads that run at a specific frequency to handle updating signals.
+ */
 public class SignalThreadBase extends Thread {
     public static final ReentrantLock SIGNALS_LOCK = new ReentrantLock();
     protected final Queue<Double> timestamps = new ArrayBlockingQueue<>(100);
     private final ThreadInputsAutoLogged threadInputs = new ThreadInputsAutoLogged();
     private final String name;
-    protected double odometryFrequencyHertz = 50;
+    protected double threadFrequencyHertz = 50;
 
+    /**
+     * Creates a new SignalThreadBase.
+     *
+     * @param name the name of the thread
+     */
     public SignalThreadBase(String name) {
         this.name = name;
     }
 
-    public void setOdometryFrequencyHertz(double odometryFrequencyHertz) {
-        this.odometryFrequencyHertz = odometryFrequencyHertz;
+    /**
+     * Sets the thread frequency in hertz.
+     * The thread frequency determines how often the robot's position and motion data are updated.
+     * A higher frequency will result in more frequent updates, but may also demand more processing power.
+     * Only used for Spark motors.
+     *
+     * @param threadFrequencyHertz the odometry frequency in hertz
+     */
+    public void setThreadFrequencyHertz(double threadFrequencyHertz) {
+        this.threadFrequencyHertz = threadFrequencyHertz;
     }
 
+    /**
+     * Updates the latest timestamps, and processes the inputs.
+     */
     public void updateLatestTimestamps() {
         if (!RobotHardwareStats.isReplay()) {
             threadInputs.timestamps = timestamps.stream().mapToDouble(Double::doubleValue).toArray();
@@ -30,6 +50,11 @@ public void updateLatestTimestamps() {
         Logger.processInputs(name, threadInputs);
     }
 
+    /**
+     * Gets the latest timestamps when signals were updated.
+     *
+     * @return the latest timestamps
+     */
     public double[] getLatestTimestamps() {
         return threadInputs.timestamps;
     }
@@ -38,4 +63,4 @@ public double[] getLatestTimestamps() {
     public static class ThreadInputs {
         public double[] timestamps;
     }
-}
+}

src/main/java/org/trigon/hardware/misc/KeyboardController.java

@@ -3,6 +3,9 @@
 import edu.wpi.first.wpilibj2.command.button.Trigger;
 import org.littletonrobotics.junction.networktables.LoggedDashboardBoolean;
 
+/**
+ * A class that represents a keyboard controller. Used to get input from a keyboard.
+ */
 public class KeyboardController {
     private final LoggedDashboardBoolean
             esc, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10,

src/main/java/org/trigon/hardware/misc/XboxController.java

@@ -5,6 +5,9 @@
 import edu.wpi.first.wpilibj2.command.WaitCommand;
 import edu.wpi.first.wpilibj2.command.button.CommandXboxController;
 
+/**
+ * A class that represents an Xbox controller. Used to get the values of the sticks and buttons on a controller, with the option of a deadband and exponentiation.
+ */
 public class XboxController extends CommandXboxController {
     private int exponent = 1;
     private double deadband = 0;

src/main/java/org/trigon/hardware/misc/leds/AddressableLEDStrip.java

@@ -152,13 +152,13 @@ void rainbow(double brightness, double speed, boolean inverted) {
     @Override
     void sectionColor(Supplier<Color>[] colors) {
         final int amountOfSections = colors.length;
-        final int LEDsPerSection = (int) Math.floor(numberOfLEDs / amountOfSections);
+        final int ledsPerSection = (int) Math.floor(numberOfLEDs / amountOfSections);
 
         for (int i = 0; i < amountOfSections; i++)
             setLEDColors(
                     inverted ? colors[amountOfSections - i - 1].get() : colors[i].get(),
-                    LEDsPerSection * i,
-                    i == amountOfSections - 1 ? numberOfLEDs - 1 : LEDsPerSection * (i + 1) - 1
+                    ledsPerSection * i,
+                    i == amountOfSections - 1 ? numberOfLEDs - 1 : ledsPerSection * (i + 1) - 1
             );
     }
 
@@ -186,7 +186,7 @@ private void setBreathingLEDs(Color color, int breathingLEDs, LarsonAnimation.Bo
         for (int i = 0; i < breathingLEDs; i++) {
             if (lastBreatheLED - i >= indexOffset && lastBreatheLED - i < indexOffset + numberOfLEDs)
                 LED_BUFFER.setLED(lastBreatheLED - i, color);
-            
+
             else if (lastBreatheLED - i < indexOffset + numberOfLEDs) {
                 if (bounceMode.equals(LarsonAnimation.BounceMode.Back) || bounceMode.equals(LarsonAnimation.BounceMode.Center) && i > breathingLEDs / 2)
                     return;

src/main/java/org/trigon/hardware/misc/leds/CANdleLEDStrip.java

@@ -15,7 +15,8 @@ public class CANdleLEDStrip extends LEDStrip {
     private final int animationSlot;
 
     /**
-     * Sets the CANdle instance to be used for controlling the LED strips. Must be set before using any LED strips. Should only be called once
+     * Sets the CANdle instance to be used for controlling the LED strips. Must be set before using any LED strips. Should only be called once.
+     * Must be configured before being set.
      *
      * @param candle the CANdle instance to be used
      */
@@ -140,19 +141,19 @@ void rainbow(double brightness, double speed, boolean inverted) {
 
     @Override
     void sectionColor(Supplier<Color>[] colors) {
-        final int LEDSPerSection = (int) Math.floor(numberOfLEDs / colors.length);
-        setSectionColor(colors.length, LEDSPerSection, colors);
+        final int ledsPerSection = (int) Math.floor(numberOfLEDs / colors.length);
+        setSectionColor(colors.length, ledsPerSection, colors);
     }
 
-    private void setSectionColor(int amountOfSections, int LEDSPerSection, Supplier<Color>[] colors) {
+    private void setSectionColor(int amountOfSections, int ledsPerSection, Supplier<Color>[] colors) {
         for (int i = 0; i < amountOfSections; i++) {
             CANDLE.setLEDs(
                     (int) (inverted ? colors[amountOfSections - i - 1].get().red : colors[i].get().red),
                     (int) (inverted ? colors[amountOfSections - i - 1].get().green : colors[i].get().green),
                     (int) (inverted ? colors[amountOfSections - i - 1].get().blue : colors[i].get().blue),
                     0,
-                    LEDSPerSection * i + indexOffset,
-                    i == amountOfSections - 1 ? numberOfLEDs - 1 : LEDSPerSection * (i + 1) - 1
+                    ledsPerSection * i + indexOffset,
+                    i == amountOfSections - 1 ? numberOfLEDs - 1 : ledsPerSection * (i + 1) - 1
             );
         }
     }

src/main/java/org/trigon/hardware/misc/leds/LEDCommands.java

@@ -23,7 +23,7 @@ public static Command getStaticColorCommand(Color color, LEDStrip... ledStrips)
         return new StartEndCommand(
                 () -> {
                     runForLEDs((LEDStrip::clearLEDColors), ledStrips);
-                    runForLEDs(LEDStrip -> LEDStrip.setCurrentAnimation(() -> LEDStrip.staticColor(color)), ledStrips);
+                    runForLEDs(ledStrip -> ledStrip.setCurrentAnimation(() -> ledStrip.staticColor(color)), ledStrips);
                 },
                 () -> runForLEDs(LEDStrip::clearLEDColors, ledStrips),
                 ledStrips
@@ -42,7 +42,7 @@ public static Command getBlinkingCommand(Color firstColor, double speed, LEDStri
         return new StartEndCommand(
                 () -> {
                     runForLEDs((LEDStrip::clearLEDColors), ledStrips);
-                    runForLEDs(LEDStrip -> LEDStrip.setCurrentAnimation(() -> LEDStrip.blink(firstColor, speed)), ledStrips);
+                    runForLEDs(ledStrip -> ledStrip.setCurrentAnimation(() -> ledStrip.blink(firstColor, speed)), ledStrips);
                 },
                 () -> runForLEDs(LEDStrip::clearLEDColors, ledStrips),
                 ledStrips
@@ -64,7 +64,7 @@ public static Command getBreatheCommand(Color color, int amountOfBreathingLEDs,
         return new StartEndCommand(
                 () -> {
                     runForLEDs((LEDStrip::clearLEDColors), ledStrips);
-                    runForLEDs(LEDStrip -> LEDStrip.setCurrentAnimation(() -> LEDStrip.breathe(color, amountOfBreathingLEDs, speed, inverted, bounceMode)), ledStrips);
+                    runForLEDs(ledStrip -> ledStrip.setCurrentAnimation(() -> ledStrip.breathe(color, amountOfBreathingLEDs, speed, inverted, bounceMode)), ledStrips);
                 },
                 () -> runForLEDs(LEDStrip::clearLEDColors, ledStrips),
                 ledStrips
@@ -84,7 +84,7 @@ public static Command getColorFlowCommand(Color color, double speed, boolean inv
         return new StartEndCommand(
                 () -> {
                     runForLEDs((LEDStrip::clearLEDColors), ledStrips);
-                    runForLEDs(LEDStrip -> LEDStrip.setCurrentAnimation(() -> LEDStrip.colorFlow(color, speed, inverted)), ledStrips);
+                    runForLEDs(ledStrip -> ledStrip.setCurrentAnimation(() -> ledStrip.colorFlow(color, speed, inverted)), ledStrips);
                 },
                 () -> runForLEDs(LEDStrip::clearLEDColors, ledStrips),
                 ledStrips
@@ -103,7 +103,7 @@ public static Command getAlternateColorCommand(Color firstColor, Color secondCol
         return new StartEndCommand(
                 () -> {
                     runForLEDs((LEDStrip::clearLEDColors), ledStrips);
-                    runForLEDs(LEDStrip -> LEDStrip.setCurrentAnimation(() -> LEDStrip.alternateColor(firstColor, secondColor)), ledStrips);
+                    runForLEDs(ledStrip -> ledStrip.setCurrentAnimation(() -> ledStrip.alternateColor(firstColor, secondColor)), ledStrips);
                 },
                 () -> runForLEDs(LEDStrip::clearLEDColors, ledStrips),
                 ledStrips
@@ -121,7 +121,7 @@ public static Command getSectionColorCommand(Supplier<Color>[] colors, LEDStrip.
         return new StartEndCommand(
                 () -> {
                     runForLEDs((LEDStrip::clearLEDColors), ledStrips);
-                    runForLEDs(LEDStrip -> LEDStrip.setCurrentAnimation(() -> LEDStrip.sectionColor(colors)), ledStrips);
+                    runForLEDs(ledStrip -> ledStrip.setCurrentAnimation(() -> ledStrip.sectionColor(colors)), ledStrips);
                 },
                 () -> runForLEDs(LEDStrip::clearLEDColors, ledStrips),
                 ledStrips
@@ -141,15 +141,15 @@ public static Command getRainbowCommand(double brightness, double speed, boolean
         return new StartEndCommand(
                 () -> {
                     runForLEDs((LEDStrip::clearLEDColors), ledStrips);
-                    runForLEDs(LEDStrip -> LEDStrip.setCurrentAnimation(() -> LEDStrip.rainbow(brightness, speed, inverted)), ledStrips);
+                    runForLEDs(ledStrip -> ledStrip.setCurrentAnimation(() -> ledStrip.rainbow(brightness, speed, inverted)), ledStrips);
                 },
                 () -> runForLEDs(LEDStrip::clearLEDColors, ledStrips),
                 ledStrips
         ).ignoringDisable(true);
     }
 
     private static void runForLEDs(Consumer<LEDStrip> action, LEDStrip... ledStrips) {
-        for (LEDStrip LEDStrip : ledStrips)
-            action.accept(LEDStrip);
+        for (LEDStrip ledStrip : ledStrips)
+            action.accept(ledStrip);
     }
 }