Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-24 01:31:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

Moved C++ comments from source files to headers (#1111)

Browse Source 
Also sorted functions in C++ sources to match order in related headers.
This commit is contained in:
Tyler Veness
2018-05-31 20:47:15 -07:00
committed by Peter Johnson
parent d9971a705a
commit 8c680a26f8
234 changed files with 9936 additions and 9309 deletions
Download Patch File Download Diff File Expand all files Collapse all files

85
wpilibc/src/main/native/include/Drive/DifferentialDrive.h
View File

@@ -101,21 +101,106 @@ class DifferentialDrive : public RobotDriveBase {
static constexpr double kDefaultQuickStopThreshold = 0.2;
static constexpr double kDefaultQuickStopAlpha = 0.1;
/**
* Construct a DifferentialDrive.
*
* To pass multiple motors per side, use a SpeedControllerGroup. If a motor
* needs to be inverted, do so before passing it in.
*/
DifferentialDrive(SpeedController& leftMotor, SpeedController& rightMotor);
~DifferentialDrive() override = default;
DifferentialDrive(const DifferentialDrive&) = delete;
DifferentialDrive& operator=(const DifferentialDrive&) = delete;
/**
* Arcade drive method for differential drive platform.
*
* Note: Some drivers may prefer inverted rotation controls. This can be done
* by negating the value passed for rotation.
*
* @param xSpeed The speed at which the robot should drive along the X
* axis [-1.0..1.0]. Forward is negative.
* @param zRotation The rotation rate of the robot around the Z axis
* [-1.0..1.0]. Clockwise is positive.
* @param squaredInputs If set, decreases the input sensitivity at low speeds.
*/
void ArcadeDrive(double xSpeed, double zRotation, bool squaredInputs = true);
/**
* Curvature drive method for differential drive platform.
*
* The rotation argument controls the curvature of the robot's path rather
* than its rate of heading change. This makes the robot more controllable at
* high speeds. Also handles the robot's quick turn functionality - "quick
* turn" overrides constant-curvature turning for turn-in-place maneuvers.
*
* @param xSpeed The robot's speed along the X axis [-1.0..1.0]. Forward
* is positive.
* @param zRotation The robot's rotation rate around the Z axis [-1.0..1.0].
* Clockwise is positive.
* @param isQuickTurn If set, overrides constant-curvature turning for
* turn-in-place maneuvers.
*/
void CurvatureDrive(double xSpeed, double zRotation, bool isQuickTurn);
/**
* Tank drive method for differential drive platform.
*
* @param leftSpeed The robot left side's speed along the X axis
* [-1.0..1.0]. Forward is positive.
* @param rightSpeed The robot right side's speed along the X axis
* [-1.0..1.0]. Forward is positive.
* @param squaredInputs If set, decreases the input sensitivity at low speeds.
*/
void TankDrive(double leftSpeed, double rightSpeed,
bool squaredInputs = true);
/**
* Sets the QuickStop speed threshold in curvature drive.
*
* QuickStop compensates for the robot's moment of inertia when stopping after
* a QuickTurn.
*
* While QuickTurn is enabled, the QuickStop accumulator takes on the rotation
* rate value outputted by the low-pass filter when the robot's speed along
* the X axis is below the threshold. When QuickTurn is disabled, the
* accumulator's value is applied against the computed angular power request
* to slow the robot's rotation.
*
* @param threshold X speed below which quick stop accumulator will receive
* rotation rate values [0..1.0].
*/
void SetQuickStopThreshold(double threshold);
/**
* Sets the low-pass filter gain for QuickStop in curvature drive.
*
* The low-pass filter filters incoming rotation rate commands to smooth out
* high frequency changes.
*
* @param alpha Low-pass filter gain [0.0..2.0]. Smaller values result in
* slower output changes. Values between 1.0 and 2.0 result in
* output oscillation. Values below 0.0 and above 2.0 are
* unstable.
*/
void SetQuickStopAlpha(double alpha);
/**
* Gets if the power sent to the right side of the drivetrain is multipled by
* -1.
*
* @return true if the right side is inverted
*/
bool IsRightSideInverted() const;
/**
* Sets if the power sent to the right side of the drivetrain should be
* multipled by -1.
*
* @param rightSideInverted true if right side power should be multipled by -1
*/
void SetRightSideInverted(bool rightSideInverted);
void StopMotor() override;

58
wpilibc/src/main/native/include/Drive/KilloughDrive.h
View File

@@ -50,18 +50,76 @@ class KilloughDrive : public RobotDriveBase {
static constexpr double kDefaultRightMotorAngle = 120.0;
static constexpr double kDefaultBackMotorAngle = 270.0;
/**
* Construct a Killough drive with the given motors and default motor angles.
*
* The default motor angles make the wheels on each corner parallel to their
* respective opposite sides.
*
* If a motor needs to be inverted, do so before passing it in.
*
* @param leftMotor The motor on the left corner.
* @param rightMotor The motor on the right corner.
* @param backMotor The motor on the back corner.
*/
KilloughDrive(SpeedController& leftMotor, SpeedController& rightMotor,
SpeedController& backMotor);
/**
* Construct a Killough drive with the given motors.
*
* Angles are measured in degrees clockwise from the positive X axis.
*
* @param leftMotor The motor on the left corner.
* @param rightMotor The motor on the right corner.
* @param backMotor The motor on the back corner.
* @param leftMotorAngle The angle of the left wheel's forward direction of
* travel.
* @param rightMotorAngle The angle of the right wheel's forward direction of
* travel.
* @param backMotorAngle The angle of the back wheel's forward direction of
* travel.
*/
KilloughDrive(SpeedController& leftMotor, SpeedController& rightMotor,
SpeedController& backMotor, double leftMotorAngle,
double rightMotorAngle, double backMotorAngle);
~KilloughDrive() override = default;
KilloughDrive(const KilloughDrive&) = delete;
KilloughDrive& operator=(const KilloughDrive&) = delete;
/**
* Drive method for Killough platform.
*
* Angles are measured clockwise from the positive X axis. The robot's speed
* is independent from its angle or rotation rate.
*
* @param ySpeed The robot's speed along the Y axis [-1.0..1.0]. Right is
* positive.
* @param xSpeed The robot's speed along the X axis [-1.0..1.0]. Forward is
* positive.
* @param zRotation The robot's rotation rate around the Z axis [-1.0..1.0].
* Clockwise is positive.
* @param gyroAngle The current angle reading from the gyro in degrees around
* the Z axis. Use this to implement field-oriented controls.
*/
void DriveCartesian(double ySpeed, double xSpeed, double zRotation,
double gyroAngle = 0.0);
/**
* Drive method for Killough platform.
*
* Angles are measured clockwise from the positive X axis. The robot's speed
* is independent from its angle or rotation rate.
*
* @param magnitude The robot's speed at a given angle [-1.0..1.0]. Forward is
* positive.
* @param angle The angle around the Z axis at which the robot drives in
* degrees [-180..180].
* @param zRotation The robot's rotation rate around the Z axis [-1.0..1.0].
* Clockwise is positive.
*/
void DrivePolar(double magnitude, double angle, double zRotation);
void StopMotor() override;

48
wpilibc/src/main/native/include/Drive/MecanumDrive.h
View File

@@ -64,19 +64,67 @@ class SpeedController;
*/
class MecanumDrive : public RobotDriveBase {
public:
/**
* Construct a MecanumDrive.
*
* If a motor needs to be inverted, do so before passing it in.
*/
MecanumDrive(SpeedController& frontLeftMotor, SpeedController& rearLeftMotor,
SpeedController& frontRightMotor,
SpeedController& rearRightMotor);
~MecanumDrive() override = default;
MecanumDrive(const MecanumDrive&) = delete;
MecanumDrive& operator=(const MecanumDrive&) = delete;
/**
* Drive method for Mecanum platform.
*
* Angles are measured clockwise from the positive X axis. The robot's speed
* is independent from its angle or rotation rate.
*
* @param ySpeed The robot's speed along the Y axis [-1.0..1.0]. Right is
* positive.
* @param xSpeed The robot's speed along the X axis [-1.0..1.0]. Forward is
* positive.
* @param zRotation The robot's rotation rate around the Z axis [-1.0..1.0].
* Clockwise is positive.
* @param gyroAngle The current angle reading from the gyro in degrees around
* the Z axis. Use this to implement field-oriented controls.
*/
void DriveCartesian(double ySpeed, double xSpeed, double zRotation,
double gyroAngle = 0.0);
/**
* Drive method for Mecanum platform.
*
* Angles are measured clockwise from the positive X axis. The robot's speed
* is independent from its angle or rotation rate.
*
* @param magnitude The robot's speed at a given angle [-1.0..1.0]. Forward is
* positive.
* @param angle The angle around the Z axis at which the robot drives in
* degrees [-180..180].
* @param zRotation The robot's rotation rate around the Z axis [-1.0..1.0].
* Clockwise is positive.
*/
void DrivePolar(double magnitude, double angle, double zRotation);
/**
* Gets if the power sent to the right side of the drivetrain is multipled by
* -1.
*
* @return true if the right side is inverted
*/
bool IsRightSideInverted() const;
/**
* Sets if the power sent to the right side of the drivetrain should be
* multipled by -1.
*
* @param rightSideInverted true if right side power should be multipled by -1
*/
void SetRightSideInverted(bool rightSideInverted);
void StopMotor() override;

39
wpilibc/src/main/native/include/Drive/RobotDriveBase.h
View File

@@ -44,9 +44,32 @@ class RobotDriveBase : public MotorSafety, public SendableBase {
RobotDriveBase(const RobotDriveBase&) = delete;
RobotDriveBase& operator=(const RobotDriveBase&) = delete;
/**
* Sets the deadband applied to the drive inputs (e.g., joystick values).
*
* The default value is 0.02. Inputs smaller than the deadband are set to 0.0
* while inputs larger than the deadband are scaled from 0.0 to 1.0. See
* ApplyDeadband().
*
* @param deadband The deadband to set.
*/
void SetDeadband(double deadband);
/**
* Configure the scaling factor for using RobotDrive with motor controllers in
* a mode other than PercentVbus or to limit the maximum output.
*
* @param maxOutput Multiplied with the output percentage computed by the
* drive functions.
*/
void SetMaxOutput(double maxOutput);
/**
* Feed the motor safety object. Resets the timer that will stop the motors if
* it completes.
*
* @see MotorSafetyHelper::Feed()
*/
void FeedWatchdog();
void SetExpiration(double timeout) override;
@@ -58,8 +81,24 @@ class RobotDriveBase : public MotorSafety, public SendableBase {
void GetDescription(wpi::raw_ostream& desc) const override = 0;
protected:
/**
* Limit motor values to the -1.0 to +1.0 range.
*/
double Limit(double number);
/**
* Returns 0.0 if the given value is within the specified range around zero.
* The remaining range between the deadband and 1.0 is scaled from 0.0 to 1.0.
*
* @param value value to clip
* @param deadband range around zero
*/
double ApplyDeadband(double number, double deadband);
/**
* Normalize all wheel speeds if the magnitude of any wheel is greater than
* 1.0.
*/
void Normalize(wpi::MutableArrayRef<double> wheelSpeeds);
double m_deadband = 0.02;

21
wpilibc/src/main/native/include/Drive/Vector2d.h
View File

@@ -16,9 +16,30 @@ struct Vector2d {
Vector2d() = default;
Vector2d(double x, double y);
/**
* Rotate a vector in Cartesian space.
*
* @param angle angle in degrees by which to rotate vector counter-clockwise.
*/
void Rotate(double angle);
/**
* Returns dot product of this vector with argument.
*
* @param vec Vector with which to perform dot product.
*/
double Dot(const Vector2d& vec) const;
/**
* Returns magnitude of vector.
*/
double Magnitude() const;
/**
* Returns scalar projection of this vector onto argument.
*
* @param vec Vector onto which to project this vector.
*/
double ScalarProject(const Vector2d& vec) const;
double x = 0.0;