PIDSubsystems ve PIDCommands üzerinden PID Kontrol

Not

Bu komut tabanlı sarmalayıcılar tarafından kullanılan WPILib PID kontrol özelliklerinin bir açıklaması için, bakınız WPILib’de PID Kontrolü

One of the most common control algorithms used in FRC® is the PID controller. WPILib offers its own PIDController class to help teams implement this functionality on their robots. To further help teams integrate PID control into a command-based robot project, the command-based library includes two convenience wrappers for the PIDController class: PIDSubsystem, which integrates the PID controller into a subsystem, and PIDCommand, which integrates the PID controller into a command.

PIDCommand

The PIDCommand class allows users to easily create commands with a built-in PIDController.

Bir PIDCommand oluşturma

A PIDCommand can be created two ways - by subclassing the PIDCommand class, or by defining the command inline. Both methods ultimately extremely similar, and ultimately the choice of which to use comes down to where the user desires that the relevant code be located.

Not

If subclassing PIDCommand and overriding any methods, make sure to call the super version of those methods! Otherwise, PID functionality will not work properly.

Her iki durumda da, gerekli parametreleri kurucusuna ileterek bir PIDCommand oluşturulur (eğer bir alt sınıf tanımlıyorsa, bu bir super() çağrısıyla yapılabilir):

Java

  /**
   * Creates a new PIDCommand, which controls the given output with a PIDController.
   *
   * @param controller the controller that controls the output.
   * @param measurementSource the measurement of the process variable
   * @param setpointSource the controller's setpoint
   * @param useOutput the controller's output
   * @param requirements the subsystems required by this command
   */
  public PIDCommand(
      PIDController controller,
      DoubleSupplier measurementSource,
      DoubleSupplier setpointSource,
      DoubleConsumer useOutput,
      Subsystem... requirements) {

C++

  /**
   * Creates a new PIDCommand, which controls the given output with a
   * PIDController.
   *
   * @param controller        the controller that controls the output.
   * @param measurementSource the measurement of the process variable
   * @param setpointSource   the controller's reference (aka setpoint)
   * @param useOutput         the controller's output
   * @param requirements      the subsystems required by this command
   */
  PIDCommand(frc::PIDController controller,
             std::function<double()> measurementSource,
             std::function<double()> setpointSource,
             std::function<void(double)> useOutput,
             Requirements requirements = {});

Kontrolör - Controller

Controller parametresi, komut tarafından kullanılacak olan PIDController nesnesidir. Bunu bilerek, kullanıcılar PID kazanımlarını, ve kontrolör için süreyi belirleyebilir (eğer kullanıcı standart olmayan bir ana robot döngü periyodu kullanıyorsa).

PIDCommand alt sınıfını oluştururken, getController() çağrısı yapılarak yapıcı gövdesindeki denetleyicide ek değişiklikler (ör. Sürekli girişi etkinleştirmek) yapılabilir.

measurementSource

The measurementSource parameter is a function (usually passed as a lambda) that returns the measurement of the process variable. Passing in the measurementSource function in PIDCommand is functionally analogous to overriding the getMeasurement() function in PIDSubsystem.

PIDCommand alt sınıfını oluştururken, ileri düzey kullanıcılar, sınıfın m_measurement alanını değiştirerek ayar noktası tedarikçisini daha da değiştirebilir.

setpointSource

The setpointSource parameter is a function (usually passed as a lambda) that returns the current setpoint for the control loop. If only a constant setpoint is needed, an overload exists that takes a constant setpoint rather than a supplier.

PIDCommand alt sınıfını oluştururken, ileri düzey kullanıcılar, sınıfın m_setpoint alanını değiştirerek ayar noktası tedarikçisini daha da değiştirebilir.

useOutput

The useOutput parameter is a function (usually passed as a lambda) that consumes the output and setpoint of the control loop. Passing in the useOutput function in PIDCommand is functionally analogous to overriding the useOutput() function in PIDSubsystem.

PIDCommand alt sınıfını oluştururken, ileri düzey kullanıcılar, sınıfın m_useOutput alanını değiştirerek çıktı tüketicisini daha da değiştirebilir.

Gereksinimler

Tüm satır içi komutlar gibi, PIDCommand kullanıcının alt sistem gereksinimlerini bir constructor parametresi olarak belirtmesine izin verir.

Tam PIDCommand Örneği

Pratikte kullanıldığında bir``PIDCommand`` neye benzer? Aşağıdaki örnekler GyroDriveCommands örnek projesinden alınmıştır (Java <https://github.com/wpilibsuite/allwpilib/tree/main/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/gyrodrivecommands> __, C ++ <https://github.com/wpilibsuite/allwpilib/tree/main/wpilibcExamples/src/main/cpp/examples/GyroDriveCommands> __):

Java

package edu.wpi.first.wpilibj.examples.gyrodrivecommands.commands;

import edu.wpi.first.math.controller.PIDController;
import edu.wpi.first.wpilibj.examples.gyrodrivecommands.Constants.DriveConstants;
import edu.wpi.first.wpilibj.examples.gyrodrivecommands.subsystems.DriveSubsystem;
import edu.wpi.first.wpilibj2.command.PIDCommand;

/** A command that will turn the robot to the specified angle. */
public class TurnToAngle extends PIDCommand {
  /**
   * Turns to robot to the specified angle.
   *
   * @param targetAngleDegrees The angle to turn to
   * @param drive The drive subsystem to use
   */
  public TurnToAngle(double targetAngleDegrees, DriveSubsystem drive) {
    super(
        new PIDController(DriveConstants.kTurnP, DriveConstants.kTurnI, DriveConstants.kTurnD),
        // Close loop on heading
        drive::getHeading,
        // Set reference to target
        targetAngleDegrees,
        // Pipe output to turn robot
        output -> drive.arcadeDrive(0, output),
        // Require the drive
        drive);

    // Set the controller to be continuous (because it is an angle controller)
    getController().enableContinuousInput(-180, 180);
    // Set the controller tolerance - the delta tolerance ensures the robot is stationary at the
    // setpoint before it is considered as having reached the reference
    getController()
        .setTolerance(DriveConstants.kTurnToleranceDeg, DriveConstants.kTurnRateToleranceDegPerS);
  }

  @Override
  public boolean isFinished() {
    // End when the controller is at the reference.
    return getController().atSetpoint();
  }
}

C++

#pragma once

#include <frc2/command/CommandHelper.h>
#include <frc2/command/PIDCommand.h>

#include "subsystems/DriveSubsystem.h"

/**
 * A command that will turn the robot to the specified angle.
 */
class TurnToAngle : public frc2::CommandHelper<frc2::PIDCommand, TurnToAngle> {
 public:
  /**
   * Turns to robot to the specified angle.
   *
   * @param targetAngleDegrees The angle to turn to
   * @param drive              The drive subsystem to use
   */
  TurnToAngle(units::degree_t target, DriveSubsystem* drive);

  bool IsFinished() override;
};

C++ (Source)

#include "commands/TurnToAngle.h"

#include <frc/controller/PIDController.h>

using namespace DriveConstants;

TurnToAngle::TurnToAngle(units::degree_t target, DriveSubsystem* drive)
    : CommandHelper{frc::PIDController{kTurnP, kTurnI, kTurnD},
                    // Close loop on heading
                    [drive] { return drive->GetHeading().value(); },
                    // Set reference to target
                    target.value(),
                    // Pipe output to turn robot
                    [drive](double output) { drive->ArcadeDrive(0, output); },
                    // Require the drive
                    {drive}} {
  // Set the controller to be continuous (because it is an angle controller)
  m_controller.EnableContinuousInput(-180, 180);
  // Set the controller tolerance - the delta tolerance ensures the robot is
  // stationary at the setpoint before it is considered as having reached the
  // reference
  m_controller.SetTolerance(kTurnTolerance.value(), kTurnRateTolerance.value());

  AddRequirements(drive);
}

bool TurnToAngle::IsFinished() {
  return GetController().AtSetpoint();
}

And, for an inlined example:

Java

    // Stabilize robot to drive straight with gyro when left bumper is held
    new JoystickButton(m_driverController, Button.kL1.value)
        .whileTrue(
            new PIDCommand(
                new PIDController(
                    DriveConstants.kStabilizationP,
                    DriveConstants.kStabilizationI,
                    DriveConstants.kStabilizationD),
                // Close the loop on the turn rate
                m_robotDrive::getTurnRate,
                // Setpoint is 0
                0,
                // Pipe the output to the turning controls
                output -> m_robotDrive.arcadeDrive(-m_driverController.getLeftY(), output),
                // Require the robot drive
                m_robotDrive));

C++

  // Stabilize robot to drive straight with gyro when L1 is held
  frc2::JoystickButton(&m_driverController, frc::PS4Controller::Button::kL1)
      .WhileTrue(
          frc2::PIDCommand(
              frc::PIDController{dc::kStabilizationP, dc::kStabilizationI,
                                 dc::kStabilizationD},
              // Close the loop on the turn rate
              [this] { return m_drive.GetTurnRate(); },
              // Setpoint is 0
              0,
              // Pipe the output to the turning controls
              [this](double output) {
                m_drive.ArcadeDrive(m_driverController.GetLeftY(), output);
              },
              // Require the robot drive
              {&m_drive})

PIDSubsystems ve PIDCommands üzerinden PID Kontrol

PIDSubsystems

PIDSubsystem oluşturma

getMeasurement()

useOutput()

Controller’a Geçirme

PIDSubsystem kullanımı

setSetpoint()

enable() ve disable()

Tam PIDSubsystem Örneği

PIDCommand

Bir PIDCommand oluşturma

Kontrolör - Controller

measurementSource

setpointSource

useOutput

Gereksinimler

Tam PIDCommand Örneği