Merge pull request #114 from robotpy/update-commands

Update commands examples

Author: virtuald

.github/workflows/test.yml

@@ -48,7 +48,7 @@ jobs:
     - name: Install deps
       run: |
         pip install -U pip
-        pip install 'robotpy[commands2]<2025.0.0,>=2024.0.0b4.post1' numpy pytest
+        pip install 'robotpy[commands2]<2025.0.0,>=2024.2.1.1' numpy pytest
     - name: Run tests
       run: bash run_tests.sh
       shell: bash

ArmBot/robotcontainer.py

@@ -45,7 +45,7 @@ def __init__(self) -> None:
                     -self.driver_controller.getLeftY(),
                     -self.driver_controller.getRightX(),
                 ),
-                [self.robot_drive],
+                self.robot_drive,
             )
         )
 
@@ -57,20 +57,20 @@ def configureButtonBindings(self) -> None:
         """
 
         # Move the arm to 2 radians above horizontal when the 'A' button is pressed.
-        self.driver_controller.A().onTrue(
-            commands2.cmd.run(lambda: self.moveArm(2), [self.robot_arm])
+        self.driver_controller.a().onTrue(
+            commands2.cmd.run(lambda: self.moveArm(2), self.robot_arm)
         )
 
         # Move the arm to neutral position when the 'B' button is pressed
-        self.driver_controller.B().onTrue(
+        self.driver_controller.b().onTrue(
             commands2.cmd.run(
                 lambda: self.moveArm(constants.ArmConstants.kArmOffsetRads),
-                [self.robot_arm],
+                self.robot_arm,
             )
         )
 
         # Disable the arm controller when Y is pressed
-        self.driver_controller.Y().onTrue(
+        self.driver_controller.y().onTrue(
             commands2.cmd.runOnce(lambda: self.robot_arm.disable())
         )
 
@@ -92,8 +92,8 @@ def getAutonomousCommand(self) -> commands2.Command:
 
         :returns: the command to run in autonomous
         """
-        return commands2.cmd.nothing()
+        return commands2.cmd.none()
 
-    def moveArm(self, radians: int) -> None:
+    def moveArm(self, radians: float) -> None:
         self.robot_arm.setGoal(radians)
         self.robot_arm.enable()

ArmBot/subsystems/armsubsystem.py

@@ -49,7 +49,7 @@ def __init__(self) -> None:
         # Start arm at rest in neutral position
         self.setGoal(constants.ArmConstants.kArmOffsetRads)
 
-    def _useOutput(
+    def useOutput(
         self, output: float, setpoint: wpimath.trajectory.TrapezoidProfile.State
     ) -> None:
         # Calculate the feedforward from the setpoint
@@ -58,5 +58,5 @@ def _useOutput(
         # Add the feedforward to the PID output to get the motor output
         self.motor.setVoltage(output + feedforward)
 
-    def _getMeasurement(self) -> float:
+    def getMeasurement(self) -> float:
         return self.encoder.getDistance() + constants.ArmConstants.kArmOffsetRads

ArmBotOffboard/robotcontainer.py

@@ -50,10 +50,10 @@ def configureButtonBindings(self) -> None:
         """
 
         # Move the arm to 2 radians above horizontal when the 'A' button is pressed.
-        self.driverController.A().onTrue(self.robotArm.setArmGoalCommand(2))
+        self.driverController.a().onTrue(self.robotArm.setArmGoalCommand(2))
 
         # Move the arm to neutral position when the 'B' button is pressed.
-        self.driverController.B().onTrue(
+        self.driverController.b().onTrue(
             self.robotArm.setArmGoalCommand(constants.kArmOffsetRads)
         )
 
@@ -66,4 +66,4 @@ def configureButtonBindings(self) -> None:
         )
 
     def getAutonomousCommand(self) -> commands2.Command:
-        return commands2.cmd.nothing()
+        return commands2.cmd.none()

ArmBotOffboard/subsystems/armsubsystem.py

@@ -48,4 +48,4 @@ def useState(self, setpoint: wpimath.trajectory.TrapezoidProfile.State) -> None:
         )
 
     def setArmGoalCommand(self, kArmOffsetRads: float) -> commands2.Command:
-        return commands2.cmd.runOnce(lambda: self.setGoal(kArmOffsetRads), [self])
+        return commands2.cmd.runOnce(lambda: self.setGoal(kArmOffsetRads), self)

ArmBotOffboard/subsystems/drivesubsystem.py

@@ -66,7 +66,7 @@ def arcadeDriveCommand(
             rot: Supplier for the commanded rotation
         """
         return commands2.cmd.run(
-            lambda: self.drive.arcadeDrive(fwd(), rot(), True), [self]
+            lambda: self.drive.arcadeDrive(fwd(), rot(), True), self
         )
 
     def resetEncoders(self) -> None:
@@ -104,6 +104,4 @@ def limitOutputCommand(self, max_output: float) -> commands2.Command:
         Args:
             maxoutput: The maximum output to which the drive will be constrained.
         """
-        return commands2.cmd.runOnce(
-            lambda: self.drive.setMaxOutput(max_output), [self]
-        )
+        return commands2.cmd.runOnce(lambda: self.drive.setMaxOutput(max_output), self)

DriveDistanceOffboard/commands/drivedistanceprofiled.py

@@ -29,14 +29,16 @@ def __init__(
                 wpimath.trajectory.TrapezoidProfile.Constraints(
                     constants.DriveConstants.kMaxSpeedMetersPerSecond,
                     constants.DriveConstants.kMaxAccelerationMetersPerSecondSquared,
-                ),
-                # End at desired position in meters; implicitly starts at 0
-                wpimath.trajectory.TrapezoidProfile.State(meters, 0),
+                )
             ),
             # Pipe the profile state to the drive
             lambda setpointState: drive.setDriveStates(setpointState, setpointState),
+            # End at desired position in meters; implicitly starts at 0
+            lambda: wpimath.trajectory.TrapezoidProfile.State(meters, 0),
+            # Current position
+            lambda: wpimath.trajectory.TrapezoidProfile.State(0, 0),
             # Require the drive
-            [drive],
+            drive,
         )
         # Reset drive encoders since we're starting at 0
         drive.resetEncoders()

DriveDistanceOffboard/robotcontainer.py

@@ -29,10 +29,10 @@ def __init__(self):
 
         # Retained command references
         self.driveFullSpeed = commands2.cmd.runOnce(
-            lambda: self.robotDrive.setMaxOutput(1), [self.robotDrive]
+            lambda: self.robotDrive.setMaxOutput(1), self.robotDrive
         )
         self.driveHalfSpeed = commands2.cmd.runOnce(
-            lambda: self.robotDrive.setMaxOutput(0.5), [self.robotDrive]
+            lambda: self.robotDrive.setMaxOutput(0.5), self.robotDrive
         )
 
         # The driver's controller
@@ -53,7 +53,7 @@ def __init__(self):
                     -self.driverController.getLeftY(),
                     -self.driverController.getRightX(),
                 ),
-                [self.robotDrive],
+                self.robotDrive,
             )
         )
 
@@ -74,31 +74,32 @@ def configureButtonBindings(self):
         )
 
         # Drive forward by 3 meters when the 'A' button is pressed, with a timeout of 10 seconds
-        self.driverController.A().onTrue(
+        self.driverController.a().onTrue(
             commands.drivedistanceprofiled.DriveDistanceProfiled(
                 3, self.robotDrive
             ).withTimeout(10)
         )
 
         # Do the same thing as above when the 'B' button is pressed, but defined inline
-        self.driverController.B().onTrue(
+        self.driverController.b().onTrue(
             commands2.TrapezoidProfileCommand(
                 wpimath.trajectory.TrapezoidProfile(
                     # Limit the max acceleration and velocity
                     wpimath.trajectory.TrapezoidProfile.Constraints(
                         constants.DriveConstants.kMaxSpeedMetersPerSecond,
                         constants.DriveConstants.kMaxAccelerationMetersPerSecondSquared,
                     ),
-                    # End at desired position in meters; implicitly starts at 0
-                    wpimath.trajectory.TrapezoidProfile.State(3, 0),
                 ),
                 # Pipe the profile state to the drive
                 lambda setpointState: self.robotDrive.setDriveStates(
                     setpointState, setpointState
                 ),
-                [self.robotDrive],
+                # End at desired position in meters; implicitly starts at 0
+                lambda: wpimath.trajectory.TrapezoidProfile.State(3, 0),
+                wpimath.trajectory.TrapezoidProfile.State,
+                self.robotDrive,
             )
-            .beforeStarting(self.robotDrive.resetEncoders())
+            .beforeStarting(self.robotDrive.resetEncoders)
             .withTimeout(10)
         )
 
@@ -108,4 +109,4 @@ def getAutonomousCommand(self) -> commands2.Command:
 
         :returns: the command to run in autonomous
         """
-        return commands2.cmd.nothing()
+        return commands2.cmd.none()

DriveDistanceOffboard/subsystems/drivesubsystem.py

@@ -96,15 +96,15 @@ def setDriveStates(
             self.feedforward.calculate(right.velocity),
         )
 
-    def getLeftEncoderDistance(self) -> wpilib.Encoder:
+    def getLeftEncoderDistance(self) -> float:
         """
         Returns the left drive encoder distance.
 
         :returns: the left drive encoder distance
         """
         return self.leftLeader.getEncoderDistance()
 
-    def getRightEncoderDistance(self) -> wpilib.Encoder:
+    def getRightEncoderDistance(self) -> float:
         """
         Returns the right drive encoder distance.
 

FrisbeeBot/robotcontainer.py

@@ -26,36 +26,30 @@ def __init__(self):
         self.robotDrive = subsystems.drivesubsystem.DriveSubsystem()
         self.shooter = subsystems.shootersubsystem.ShooterSubsystem()
 
-        self.spinUpShooter = commands2.cmd.runOnce(self.shooter.enable, [self.shooter])
-        self.stopShooter = commands2.cmd.runOnce(self.shooter.disable, [self.shooter])
+        self.spinUpShooter = commands2.cmd.runOnce(self.shooter.enable, self.shooter)
+        self.stopShooter = commands2.cmd.runOnce(self.shooter.disable, self.shooter)
 
         # An autonomous routine that shoots the loaded frisbees
         self.autonomousCommand = commands2.cmd.sequence(
-            [
-                # Start the command by spinning up the shooter...
-                commands2.cmd.runOnce(self.shooter.enable, [self.shooter]),
-                # Wait until the shooter is at speed before feeding the frisbees
-                commands2.cmd.waitUntil(
-                    lambda: self.shooter.getController().atSetpoint()
-                ),
-                # Start running the feeder
-                commands2.cmd.runOnce(self.shooter.runFeeder, [self.shooter]),
-                # Shoot for the specified time
-                commands2.cmd.wait(constants.AutoConstants.kAutoShootTimeSeconds)
-                # Add a timeout (will end the command if, for instance, the shooter
-                # never gets up to speed)
-                .withTimeout(constants.AutoConstants.kAutoTimeoutSeconds)
-                # When the command ends, turn off the shooter and the feeder
-                .andThen(
-                    commands2.cmd.runOnce(
-                        lambda: self.shooter.disable, [self.shooter]
-                    ).andThen(
-                        commands2.cmd.runOnce(
-                            lambda: self.shooter.stopFeeder, [self.shooter]
-                        )
-                    )
-                ),
-            ]
+            # Start the command by spinning up the shooter...
+            commands2.cmd.runOnce(self.shooter.enable, self.shooter),
+            # Wait until the shooter is at speed before feeding the frisbees
+            commands2.cmd.waitUntil(lambda: self.shooter.getController().atSetpoint()),
+            # Start running the feeder
+            commands2.cmd.runOnce(self.shooter.runFeeder, self.shooter),
+            # Shoot for the specified time
+            commands2.cmd.waitSeconds(constants.AutoConstants.kAutoShootTimeSeconds)
+            # Add a timeout (will end the command if, for instance, the shooter
+            # never gets up to speed)
+            .withTimeout(constants.AutoConstants.kAutoTimeoutSeconds)
+            # When the command ends, turn off the shooter and the feeder
+            .andThen(
+                commands2.cmd.runOnce(
+                    lambda: self.shooter.disable, self.shooter
+                ).andThen(
+                    commands2.cmd.runOnce(lambda: self.shooter.stopFeeder, self.shooter)
+                )
+            ),
         )
 
         # The driver's controller
@@ -76,7 +70,7 @@ def __init__(self):
                     -self.driverController.getLeftY(),
                     -self.driverController.getRightX(),
                 ),
-                [self.robotDrive],
+                self.robotDrive,
             )
         )
 
@@ -92,39 +86,39 @@ def configureButtonBindings(self):
         # We can bind commands while retaining references to them in RobotContainer
 
         # Spin up the shooter when the 'A' button is pressed
-        self.driverController.A().onTrue(self.spinUpShooter)
+        self.driverController.a().onTrue(self.spinUpShooter)
 
         # Turn off the shooter when the 'B' button is pressed
-        self.driverController.B().onTrue(self.stopShooter)
+        self.driverController.b().onTrue(self.stopShooter)
 
         # We can also write them as temporary variables outside the bindings
 
         # Shoots if the shooter wheel has reached the target speed
         shoot = commands2.cmd.either(
             # Run the feeder
-            commands2.cmd.runOnce(self.shooter.runFeeder, [self.shooter]),
+            commands2.cmd.runOnce(self.shooter.runFeeder, self.shooter),
             # Do nothing
-            commands2.cmd.nothing(),
+            commands2.cmd.none(),
             # Determine which of the above to do based on whether the shooter has reached the
             # desired speed
             lambda: self.shooter.getController().atSetpoint(),
         )
 
-        stopFeeder = commands2.cmd.runOnce(self.shooter.stopFeeder, [self.shooter])
+        stopFeeder = commands2.cmd.runOnce(self.shooter.stopFeeder, self.shooter)
 
         # Shoot when the 'X' button is pressed
-        self.driverController.X().onTrue(shoot).onFalse(stopFeeder)
+        self.driverController.x().onTrue(shoot).onFalse(stopFeeder)
 
         # We can also define commands inline at the binding!
 
         # While holding the shoulder button, drive at half speed
         self.driverController.rightBumper().onTrue(
             commands2.cmd.runOnce(
-                lambda: self.robotDrive.setMaxOutput(0.5), [self.robotDrive]
+                lambda: self.robotDrive.setMaxOutput(0.5), self.robotDrive
             )
         ).onFalse(
             commands2.cmd.runOnce(
-                lambda: self.robotDrive.setMaxOutput(1), [self.robotDrive]
+                lambda: self.robotDrive.setMaxOutput(1), self.robotDrive
             )
         )