Merge pull request #250 from pjreiniger/copybara_allwpilib_to_mostrobotpy

[copybara] Resync allwpilib

Author: virtuald

examples/robot/AddressableLED/robot.py

@@ -32,8 +32,8 @@ def __init__(self) -> None:
         self.kLedSpacing = 1 / 120.0
 
         # Create a new pattern that scrolls the rainbow pattern across the LED strip, moving at a
-        # speed of 1 meter per second.
-        self.scrollingRainbow = self.rainbow.scrollAtAbsoluteSpeed(
+        # velocity of 1 meter per second.
+        self.scrollingRainbow = self.rainbow.scrollAtAbsoluteVelocity(
             1,
             self.kLedSpacing,
         )

examples/robot/ArmSimulation/subsystems/arm.py

@@ -76,7 +76,7 @@ def simulationPeriodic(self) -> None:
         # In this method, we update our simulation of what our arm is doing
         # First, we set our "inputs" (voltages)
         self.armSim.setInput(
-            [self.motor.get() * wpilib.RobotController.getBatteryVoltage()]
+            [self.motor.getDutyCycle() * wpilib.RobotController.getBatteryVoltage()]
         )
 
         # Next, we update it. The standard loop time is 20ms.
@@ -111,4 +111,4 @@ def reachSetpoint(self) -> None:
         self.motor.setVoltage(pidOutput)
 
     def stop(self) -> None:
-        self.motor.set(0.0)
+        self.motor.setDutyCycle(0.0)

examples/robot/DifferentialDriveBot/drivetrain.py

@@ -12,8 +12,8 @@
 class Drivetrain:
     """Represents a differential drive style drivetrain."""
 
-    kMaxSpeed = 3.0  # meters per second
-    kMaxAngularSpeed = 2 * math.pi  # one rotation per second
+    kMaxVelocity = 3.0  # meters per second
+    kMaxAngularVelocity = 2 * math.pi  # one rotation per second
 
     kTrackwidth = 0.381 * 2  # meters
     kWheelRadius = 0.0508  # meters
@@ -68,35 +68,37 @@ def __init__(self) -> None:
             self.rightEncoder.getDistance(),
         )
 
-    def setSpeeds(self, speeds: wpimath.DifferentialDriveWheelSpeeds) -> None:
-        """Sets the desired wheel speeds.
+    def setVelocities(
+        self, velocities: wpimath.DifferentialDriveWheelVelocities
+    ) -> None:
+        """Sets the desired wheel velocities.
 
-        :param speeds: The desired wheel speeds.
+        :param velocities: The desired wheel velocities.
         """
-        leftFeedforward = self.feedforward.calculate(speeds.left)
-        rightFeedforward = self.feedforward.calculate(speeds.right)
+        leftFeedforward = self.feedforward.calculate(velocities.left)
+        rightFeedforward = self.feedforward.calculate(velocities.right)
 
         leftOutput = self.leftPIDController.calculate(
-            self.leftEncoder.getRate(), speeds.left
+            self.leftEncoder.getRate(), velocities.left
         )
         rightOutput = self.rightPIDController.calculate(
-            self.rightEncoder.getRate(), speeds.right
+            self.rightEncoder.getRate(), velocities.right
         )
 
         # Controls the left and right sides of the robot using the calculated outputs
         self.leftLeader.setVoltage(leftOutput + leftFeedforward)
         self.rightLeader.setVoltage(rightOutput + rightFeedforward)
 
-    def drive(self, xSpeed: float, rot: float) -> None:
+    def drive(self, xVelocity: float, rot: float) -> None:
         """Drives the robot with the given linear velocity and angular velocity.
 
-        :param xSpeed: Linear velocity in m/s.
+        :param xVelocity: Linear velocity in m/s.
         :param rot: Angular velocity in rad/s.
         """
-        wheelSpeeds = self.kinematics.toWheelSpeeds(
-            wpimath.ChassisSpeeds(xSpeed, 0.0, rot)
+        wheelVelocities = self.kinematics.toWheelVelocities(
+            wpimath.ChassisVelocities(xVelocity, 0.0, rot)
         )
-        self.setSpeeds(wheelSpeeds)
+        self.setVelocities(wheelVelocities)
 
     def updateOdometry(self) -> None:
         """Updates the field-relative position."""

examples/robot/DifferentialDriveBot/robot.py

@@ -19,19 +19,19 @@ def __init__(self) -> None:
         self.drive = Drivetrain()
 
         # Slew rate limiters to make joystick inputs more gentle; 1/3 sec from 0 to 1.
-        self.speedLimiter = wpimath.SlewRateLimiter(3)
+        self.velocityLimiter = wpimath.SlewRateLimiter(3)
         self.rotLimiter = wpimath.SlewRateLimiter(3)
 
     def autonomousPeriodic(self) -> None:
         self.teleopPeriodic()
         self.drive.updateOdometry()
 
     def teleopPeriodic(self) -> 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.speedLimiter.calculate(self.controller.getLeftY())
-            * Drivetrain.kMaxSpeed
+        xVelocity = (
+            -self.velocityLimiter.calculate(self.controller.getLeftY())
+            * Drivetrain.kMaxVelocity
         )
 
         # Get the rate of angular rotation. We are inverting this because we want a
@@ -40,7 +40,7 @@ def teleopPeriodic(self) -> None:
         # the right by default.
         rot = (
             -self.rotLimiter.calculate(self.controller.getRightX())
-            * Drivetrain.kMaxAngularSpeed
+            * Drivetrain.kMaxAngularVelocity
         )
 
-        self.drive.drive(xSpeed, rot)
+        self.drive.drive(xVelocity, rot)

examples/robot/DifferentialDrivePoseEstimator/drivetrain.py

@@ -17,8 +17,8 @@
 class Drivetrain:
     """Represents a differential drive style drivetrain."""
 
-    kMaxSpeed = 3.0  # meters per second
-    kMaxAngularSpeed = math.tau  # one rotation per second
+    kMaxVelocity = 3.0  # meters per second
+    kMaxAngularVelocity = math.tau  # one rotation per second
 
     kTrackwidth = 0.381 * 2  # meters
     kWheelRadius = 0.0508  # meters
@@ -111,33 +111,35 @@ def __init__(self, cameraToObjectTopic: ntcore.DoubleArrayTopic) -> None:
         wpilib.SmartDashboard.putData("Field", self.fieldSim)
         wpilib.SmartDashboard.putData("FieldEstimation", self.fieldApproximation)
 
-    def setSpeeds(self, speeds: wpimath.DifferentialDriveWheelSpeeds) -> None:
-        """Sets the desired wheel speeds.
+    def setVelocities(
+        self, velocities: wpimath.DifferentialDriveWheelVelocities
+    ) -> None:
+        """Sets the desired wheel velocities.
 
-        :param speeds: The desired wheel speeds.
+        :param velocities: The desired wheel velocities.
         """
-        leftFeedforward = self.feedforward.calculate(speeds.left)
-        rightFeedforward = self.feedforward.calculate(speeds.right)
+        leftFeedforward = self.feedforward.calculate(velocities.left)
+        rightFeedforward = self.feedforward.calculate(velocities.right)
 
         leftOutput = self.leftPIDController.calculate(
-            self.leftEncoder.getRate(), speeds.left
+            self.leftEncoder.getRate(), velocities.left
         )
         rightOutput = self.rightPIDController.calculate(
-            self.rightEncoder.getRate(), speeds.right
+            self.rightEncoder.getRate(), velocities.right
         )
         self.leftLeader.setVoltage(leftOutput + leftFeedforward)
         self.rightLeader.setVoltage(rightOutput + rightFeedforward)
 
-    def drive(self, xSpeed: float, rot: float) -> None:
+    def drive(self, xVelocity: float, rot: float) -> None:
         """Drives the robot with the given linear velocity and angular velocity.
 
-        :param xSpeed: Linear velocity in m/s.
+        :param xVelocity: Linear velocity in m/s.
         :param rot: Angular velocity in rad/s.
         """
-        wheelSpeeds = self.kinematics.toWheelSpeeds(
-            wpimath.ChassisSpeeds(xSpeed, 0.0, rot)
+        wheelVelocities = self.kinematics.toWheelVelocities(
+            wpimath.ChassisVelocities(xVelocity, 0.0, rot)
         )
-        self.setSpeeds(wheelSpeeds)
+        self.setVelocities(wheelVelocities)
 
     def publishCameraToObject(
         self,
@@ -242,8 +244,8 @@ def simulationPeriodic(self) -> None:
         # simulation, and write the simulated positions and velocities to our
         # simulated encoder and gyro.
         self.drivetrainSimulator.setInputs(
-            self.leftLeader.get() * wpilib.RobotController.getInputVoltage(),
-            self.rightLeader.get() * wpilib.RobotController.getInputVoltage(),
+            self.leftLeader.getDutyCycle() * wpilib.RobotController.getInputVoltage(),
+            self.rightLeader.getDutyCycle() * wpilib.RobotController.getInputVoltage(),
         )
         self.drivetrainSimulator.update(0.02)
 

examples/robot/DifferentialDrivePoseEstimator/robot.py

@@ -23,7 +23,7 @@ def __init__(self) -> None:
         self.drive = Drivetrain(self.doubleArrayTopic)
 
         # Slew rate limiters to make joystick inputs more gentle; 1/3 sec from 0 to 1.
-        self.speedLimiter = wpimath.SlewRateLimiter(3)
+        self.velocityLimiter = wpimath.SlewRateLimiter(3)
         self.rotLimiter = wpimath.SlewRateLimiter(3)
 
     def autonomousPeriodic(self) -> None:
@@ -37,16 +37,16 @@ def robotPeriodic(self) -> None:
         self.drive.periodic()
 
     def teleopPeriodic(self) -> 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.speedLimiter.calculate(self.controller.getLeftY())
-        xSpeed *= Drivetrain.kMaxSpeed
+        xVelocity = -self.velocityLimiter.calculate(self.controller.getLeftY())
+        xVelocity *= Drivetrain.kMaxVelocity
 
         # Get the rate of angular rotation. We are inverting this because we want a
         # positive value when we pull to the left (remember, CCW is positive in
         # mathematics). Xbox controllers return positive values when you pull to
         # the right by default.
         rot = -self.rotLimiter.calculate(self.controller.getRightX())
-        rot *= Drivetrain.kMaxAngularSpeed
+        rot *= Drivetrain.kMaxAngularVelocity
 
-        self.drive.drive(xSpeed, rot)
+        self.drive.drive(xVelocity, rot)

examples/robot/DriveDistanceOffboard/constants.py

@@ -32,7 +32,7 @@ class DriveConstants:
 
     kp = 1.0
 
-    kMaxSpeed = 3.0  # m/s
+    kMaxVelocity = 3.0  # m/s
     kMaxAcceleration = 3.0  # m/s²
 
 

examples/robot/DriveDistanceOffboard/examplesmartmotorcontroller.py

@@ -8,7 +8,7 @@
 import enum
 
 
-class ExampleSmartMotorController(wpilib.MotorController):
+class ExampleSmartMotorController:
     """A simplified stub class that simulates the API of a common "smart" motor controller.
     Has no actual functionality.
     """
@@ -25,7 +25,7 @@ def __init__(self, port: int) -> None:
             port: The port for the controller.
         """
         super().__init__()
-        self._speed = 0.0
+        self._velocity = 0.0
         self._inverted = False
         self._leader = None
 
@@ -79,11 +79,11 @@ def resetEncoder(self) -> None:
         """Resets the encoder to zero distance."""
         pass
 
-    def set(self, speed: float) -> None:
-        self._speed = -speed if self._inverted else speed
+    def set(self, velocity: float) -> None:
+        self._velocity = -velocity if self._inverted else velocity
 
     def get(self) -> float:
-        return self._speed
+        return self._velocity
 
     def setInverted(self, isInverted: bool) -> None:
         self._inverted = isInverted
@@ -92,7 +92,7 @@ def getInverted(self) -> bool:
         return self._inverted
 
     def disable(self) -> None:
-        self._speed = 0.0
+        self._velocity = 0.0
 
     def stopMotor(self) -> None:
-        self._speed = 0.0
+        self._velocity = 0.0

examples/robot/DriveDistanceOffboard/robotcontainer.py

@@ -25,10 +25,10 @@ def __init__(self):
         self.robotDrive = subsystems.drivesubsystem.DriveSubsystem()
 
         # Retained command references
-        self.driveFullSpeed = commands2.cmd.runOnce(
+        self.driveFullVelocity = commands2.cmd.runOnce(
             lambda: self.robotDrive.setMaxOutput(1), self.robotDrive
         )
-        self.driveHalfSpeed = commands2.cmd.runOnce(
+        self.driveHalfVelocity = commands2.cmd.runOnce(
             lambda: self.robotDrive.setMaxOutput(0.5), self.robotDrive
         )
 
@@ -65,9 +65,9 @@ def configureButtonBindings(self):
 
         # We can bind commands while retaining references to them in RobotContainer
 
-        # Drive at half speed when the bumper is held
-        self.driverController.rightBumper().onTrue(self.driveHalfSpeed).onFalse(
-            self.driveFullSpeed
+        # Drive at half velocity when the bumper is held
+        self.driverController.rightBumper().onTrue(self.driveHalfVelocity).onFalse(
+            self.driveFullVelocity
         )
 
         # Drive forward by 3 meters when the 'A' button is pressed, with a timeout of 10 seconds

examples/robot/DriveDistanceOffboard/subsystems/drivesubsystem.py

@@ -59,11 +59,11 @@ def __init__(self) -> None:
         )
 
         # The robot's drive
-        self.drive = wpilib.DifferentialDrive(self.leftLeader, self.rightLeader)
+        self.drive = wpilib.DifferentialDrive(self.leftLeader.set, self.rightLeader.set)
 
         self.profile = wpimath.TrapezoidProfile(
             wpimath.TrapezoidProfile.Constraints(
-                constants.DriveConstants.kMaxSpeed,
+                constants.DriveConstants.kMaxVelocity,
                 constants.DriveConstants.kMaxAcceleration,
             )
         )