[wpimath] Replace Speeds with Velocities (#8479)

I left "free speed" alone since that's the technical term for it. In
general, velocity is a vector quantity, and speed is a magnitude (i.e.,
a strictly positive value).

This PR also replaces the speed verbiage in MotorController with duty
cycle.

Fixes #8423.

robotpyExamples/MecanumBot/drivetrain.py

@@ -12,8 +12,8 @@ import wpimath
 class Drivetrain:
     """Represents a mecanum drive style drivetrain."""
 
-    kMaxSpeed = 3.0  # 3 meters per second
-    kMaxAngularSpeed = math.pi  # 1/2 rotation per second
+    kMaxVelocity = 3.0  # 3 meters per second
+    kMaxAngularVelocity = math.pi  # 1/2 rotation per second
 
     def __init__(self) -> None:
         self.frontLeftMotor = wpilib.PWMSparkMax(1)
@@ -60,9 +60,9 @@ class Drivetrain:
         self.frontRightMotor.setInverted(True)
         self.backRightMotor.setInverted(True)
 
-    def getCurrentState(self) -> wpimath.MecanumDriveWheelSpeeds:
+    def getCurrentState(self) -> wpimath.MecanumDriveWheelVelocities:
         """Returns the current state of the drivetrain."""
-        return wpimath.MecanumDriveWheelSpeeds(
+        return wpimath.MecanumDriveWheelVelocities(
             self.frontLeftEncoder.getRate(),
             self.frontRightEncoder.getRate(),
             self.backLeftEncoder.getRate(),
@@ -78,24 +78,24 @@ class Drivetrain:
         positions.rearRight = self.backRightEncoder.getDistance()
         return positions
 
-    def setSpeeds(self, speeds: wpimath.MecanumDriveWheelSpeeds) -> None:
-        """Sets the desired speeds for each wheel."""
-        frontLeftFeedforward = self.feedforward.calculate(speeds.frontLeft)
-        frontRightFeedforward = self.feedforward.calculate(speeds.frontRight)
-        backLeftFeedforward = self.feedforward.calculate(speeds.rearLeft)
-        backRightFeedforward = self.feedforward.calculate(speeds.rearRight)
+    def setVelocities(self, velocities: wpimath.MecanumDriveWheelVelocities) -> None:
+        """Sets the desired velocities for each wheel."""
+        frontLeftFeedforward = self.feedforward.calculate(velocities.frontLeft)
+        frontRightFeedforward = self.feedforward.calculate(velocities.frontRight)
+        backLeftFeedforward = self.feedforward.calculate(velocities.rearLeft)
+        backRightFeedforward = self.feedforward.calculate(velocities.rearRight)
 
         frontLeftOutput = self.frontLeftPIDController.calculate(
-            self.frontLeftEncoder.getRate(), speeds.frontLeft
+            self.frontLeftEncoder.getRate(), velocities.frontLeft
         )
         frontRightOutput = self.frontRightPIDController.calculate(
-            self.frontRightEncoder.getRate(), speeds.frontRight
+            self.frontRightEncoder.getRate(), velocities.frontRight
         )
         backLeftOutput = self.frontLeftPIDController.calculate(
-            self.backLeftEncoder.getRate(), speeds.rearLeft
+            self.backLeftEncoder.getRate(), velocities.rearLeft
         )
         backRightOutput = self.frontRightPIDController.calculate(
-            self.backRightEncoder.getRate(), speeds.rearRight
+            self.backRightEncoder.getRate(), velocities.rearRight
         )
 
         self.frontLeftMotor.setVoltage(frontLeftOutput + frontLeftFeedforward)
@@ -105,21 +105,21 @@ class Drivetrain:
 
     def drive(
         self,
-        xSpeed: float,
-        ySpeed: float,
+        xVelocity: float,
+        yVelocity: float,
         rot: float,
         fieldRelative: bool,
         periodSeconds: float,
     ) -> None:
         """Method to drive the robot using joystick info."""
-        chassisSpeeds = wpimath.ChassisSpeeds(xSpeed, ySpeed, rot)
+        chassisVelocities = wpimath.ChassisVelocities(xVelocity, yVelocity, rot)
         if fieldRelative:
-            chassisSpeeds = chassisSpeeds.toRobotRelative(self.imu.getRotation2d())
+            chassisVelocities = chassisVelocities.toRobotRelative(self.imu.getRotation2d())
 
-        self.setSpeeds(
-            self.kinematics.toWheelSpeeds(
-                chassisSpeeds.discretize(periodSeconds)
-            ).desaturate(self.kMaxSpeed)
+        self.setVelocities(
+            self.kinematics.toWheelVelocities(
+                chassisVelocities.discretize(periodSeconds)
+            ).desaturate(self.kMaxVelocity)
         )
 
     def updateOdometry(self) -> None:

robotpyExamples/MecanumBot/robot.py

@@ -19,8 +19,8 @@ class MyRobot(wpilib.TimedRobot):
         self.mecanum = Drivetrain()
 
         # Slew rate limiters to make joystick inputs more gentle; 1/3 sec from 0 to 1.
-        self.xspeedLimiter = wpimath.SlewRateLimiter(3)
-        self.yspeedLimiter = wpimath.SlewRateLimiter(3)
+        self.xvelocityLimiter = wpimath.SlewRateLimiter(3)
+        self.yvelocityLimiter = wpimath.SlewRateLimiter(3)
         self.rotLimiter = wpimath.SlewRateLimiter(3)
 
     def autonomousPeriodic(self) -> None:
@@ -31,19 +31,19 @@ class MyRobot(wpilib.TimedRobot):
         self.driveWithJoystick(True)
 
     def driveWithJoystick(self, fieldRelative: bool) -> None:
-        # Get the x speed. We are inverting this because Xbox controllers return
+        # Get the x velocity. We are inverting this because Xbox controllers return
         # negative values when we push forward.
-        xSpeed = (
-            -self.xspeedLimiter.calculate(self.controller.getLeftY())
-            * Drivetrain.kMaxSpeed
+        xVelocity = (
+            -self.xvelocityLimiter.calculate(self.controller.getLeftY())
+            * Drivetrain.kMaxVelocity
         )
 
-        # Get the y speed or sideways/strafe speed. We are inverting this because
+        # Get the y velocity or sideways/strafe velocity. We are inverting this because
         # we want a positive value when we pull to the left. Xbox controllers
         # return positive values when you pull to the right by default.
-        ySpeed = (
-            -self.yspeedLimiter.calculate(self.controller.getLeftX())
-            * Drivetrain.kMaxSpeed
+        yVelocity = (
+            -self.yvelocityLimiter.calculate(self.controller.getLeftX())
+            * Drivetrain.kMaxVelocity
         )
 
         # Get the rate of angular rotation. We are inverting this because we want a
@@ -52,7 +52,7 @@ class MyRobot(wpilib.TimedRobot):
         # the right by default.
         rot = (
             -self.rotLimiter.calculate(self.controller.getRightX())
-            * Drivetrain.kMaxAngularSpeed
+            * Drivetrain.kMaxAngularVelocity
         )
 
-        self.mecanum.drive(xSpeed, ySpeed, rot, fieldRelative, self.getPeriod())
+        self.mecanum.drive(xVelocity, yVelocity, rot, fieldRelative, self.getPeriod())