Remove m_ from all examples

Author: Gold856

robotpyExamples/DifferentialDrivePoseEstimator/robot.py

@@ -17,7 +17,7 @@ def __init__(self) -> None:
         super().__init__()
 
         self.inst = ntcore.NetworkTableInstance.getDefault()
-        self.doubleArrayTopic = self.inst.getDoubleArrayTopic("m_doubleArrayTopic")
+        self.doubleArrayTopic = self.inst.getDoubleArrayTopic("doubleArrayTopic")
 
         self.controller = wpilib.NiDsXboxController(0)
         self.drive = Drivetrain(self.doubleArrayTopic)

robotpyExamples/SwerveDrivePoseEstimator/swervemodule.py

@@ -112,21 +112,17 @@ def setDesiredVelocity(self, desiredVelocity: wpimath.SwerveModuleVelocity) -> N
             encoderRotation
         )
 
-        # Calculate the drive output from the drive PID controller.
+        # Calculate the drive output from the drive PID controller and feedforward.
         driveOutput = self.drivePIDController.calculate(
             self.driveEncoder.getRate(), velocity.velocity
-        )
-
-        driveFeedforward = self.driveFeedforward.calculate(velocity.velocity)
+        ) + self.driveFeedforward.calculate(velocity.velocity)
 
-        # Calculate the turning motor output from the turning PID controller.
+        # Calculate the turning motor output from the turning PID controller and feedforward.
         turnOutput = self.turningPIDController.calculate(
             self.turningEncoder.getDistance(), velocity.angle.radians()
-        )
-
-        turnFeedforward = self.turnFeedforward.calculate(
+        ) + self.turnFeedforward.calculate(
             self.turningPIDController.getSetpoint().velocity
         )
 
-        self.driveMotor.setVoltage(driveOutput + driveFeedforward)
-        self.turningMotor.setVoltage(turnOutput + turnFeedforward)
+        self.driveMotor.setVoltage(driveOutput)
+        self.turningMotor.setVoltage(turnOutput)

shared/java/javastyle.gradle

@@ -89,4 +89,4 @@ task javaFormat {
 javaFormat.dependsOn 'spotlessApply'
 tasks.withType(Checkstyle) {
     it.mustRunAfter 'spotlessApply'
-}
+}

styleguide/pmd-ruleset.xml

@@ -12,7 +12,7 @@
   <exclude-pattern>.*/Timestamped.*\.java</exclude-pattern>
   <exclude-pattern>.*/units/measure/.*\.java</exclude-pattern>
 
-  <exclude-pattern>.*/*IntegrationTests.*</exclude-pattern>
+  <exclude-pattern>.*/*Examples.*</exclude-pattern>
   <exclude-pattern>.*/*JNI.*</exclude-pattern>
   <exclude-pattern>.*/math/proto.*</exclude-pattern>
   <exclude-pattern>.*/command3/proto.*</exclude-pattern>

wpilibcExamples/src/main/cpp/examples/ArcadeDriveGamepad/cpp/Robot.cpp

@@ -12,30 +12,30 @@
  * Runs the motors with split arcade steering and a Gamepad.
  */
 class Robot : public wpi::TimedRobot {
-  wpi::PWMSparkMax m_leftMotor{0};
-  wpi::PWMSparkMax m_rightMotor{1};
-  wpi::DifferentialDrive m_robotDrive{
-      [&](double output) { m_leftMotor.SetThrottle(output); },
-      [&](double output) { m_rightMotor.SetThrottle(output); }};
-  wpi::Gamepad m_driverController{0};
+  wpi::PWMSparkMax leftMotor{0};
+  wpi::PWMSparkMax rightMotor{1};
+  wpi::DifferentialDrive robotDrive{
+      [&](double output) { leftMotor.SetThrottle(output); },
+      [&](double output) { rightMotor.SetThrottle(output); }};
+  wpi::Gamepad driverController{0};
 
  public:
   Robot() {
-    wpi::util::SendableRegistry::AddChild(&m_robotDrive, &m_leftMotor);
-    wpi::util::SendableRegistry::AddChild(&m_robotDrive, &m_rightMotor);
+    wpi::util::SendableRegistry::AddChild(&robotDrive, &leftMotor);
+    wpi::util::SendableRegistry::AddChild(&robotDrive, &rightMotor);
 
     // We need to invert one side of the drivetrain so that positive voltages
     // result in both sides moving forward. Depending on how your robot's
     // gearbox is constructed, you might have to invert the left side instead.
-    m_rightMotor.SetInverted(true);
+    rightMotor.SetInverted(true);
   }
 
   void TeleopPeriodic() override {
     // Drive with split arcade style
     // That means that the Y axis of the left stick moves forward
     // and backward, and the X of the right stick turns left and right.
-    m_robotDrive.ArcadeDrive(-m_driverController.GetLeftY(),
-                             -m_driverController.GetRightX());
+    robotDrive.ArcadeDrive(-driverController.GetLeftY(),
+                           -driverController.GetRightX());
   }
 };
 

wpilibcExamples/src/main/cpp/examples/ArmSimulation/cpp/Robot.cpp

@@ -5,26 +5,26 @@
 #include "Robot.hpp"
 
 void Robot::SimulationPeriodic() {
-  m_arm.SimulationPeriodic();
+  arm.SimulationPeriodic();
 }
 
 void Robot::TeleopInit() {
-  m_arm.LoadPreferences();
+  arm.LoadPreferences();
 }
 
 void Robot::TeleopPeriodic() {
-  if (m_joystick.GetTrigger()) {
+  if (joystick.GetTrigger()) {
     // Here, we run PID control like normal.
-    m_arm.ReachSetpoint();
+    arm.ReachSetpoint();
   } else {
     // Otherwise, we disable the motor.
-    m_arm.Stop();
+    arm.Stop();
   }
 }
 
 void Robot::DisabledInit() {
   // This just makes sure that our simulation code knows that the motor's off.
-  m_arm.Stop();
+  arm.Stop();
 }
 
 #ifndef RUNNING_WPILIB_TESTS

wpilibcExamples/src/main/cpp/examples/ArmSimulation/cpp/subsystems/Arm.cpp

@@ -9,55 +9,55 @@
 #include "wpi/util/Preferences.hpp"
 
 Arm::Arm() {
-  m_encoder.SetDistancePerPulse(kArmEncoderDistPerPulse);
+  encoder.SetDistancePerPulse(kArmEncoderDistPerPulse);
 
   // Put Mechanism 2d to SmartDashboard
-  wpi::SmartDashboard::PutData("Arm Sim", &m_mech2d);
+  wpi::SmartDashboard::PutData("Arm Sim", &mech2d);
 
   // Set the Arm position setpoint and P constant to Preferences if the keys
   // don't already exist
-  wpi::Preferences::InitDouble(kArmPositionKey, m_armSetpoint.value());
-  wpi::Preferences::InitDouble(kArmPKey, m_armKp);
+  wpi::Preferences::InitDouble(kArmPositionKey, armSetpoint.value());
+  wpi::Preferences::InitDouble(kArmPKey, armKp);
 }
 
 void Arm::SimulationPeriodic() {
   // In this method, we update our simulation of what our arm is doing
   // First, we set our "inputs" (voltages)
-  m_armSim.SetInput(wpi::math::Vectord<1>{
-      m_motor.GetThrottle() * wpi::RobotController::GetInputVoltage()});
+  armSim.SetInput(wpi::math::Vectord<1>{
+      motor.GetThrottle() * wpi::RobotController::GetInputVoltage()});
 
   // Next, we update it. The standard loop time is 20ms.
-  m_armSim.Update(20_ms);
+  armSim.Update(20_ms);
 
   // Finally, we set our simulated encoder's readings and simulated battery
   // voltage
-  m_encoderSim.SetDistance(m_armSim.GetAngle().value());
+  encoderSim.SetDistance(armSim.GetAngle().value());
   // SimBattery estimates loaded battery voltages
   wpi::sim::RoboRioSim::SetVInVoltage(
-      wpi::sim::BatterySim::Calculate({m_armSim.GetCurrentDraw()}));
+      wpi::sim::BatterySim::Calculate({armSim.GetCurrentDraw()}));
 
   // Update the Mechanism Arm angle based on the simulated arm angle
-  m_arm->SetAngle(m_armSim.GetAngle());
+  arm->SetAngle(armSim.GetAngle());
 }
 
 void Arm::LoadPreferences() {
   // Read Preferences for Arm setpoint and kP on entering Teleop
-  m_armSetpoint = wpi::units::degree_t{
-      wpi::Preferences::GetDouble(kArmPositionKey, m_armSetpoint.value())};
-  if (m_armKp != wpi::Preferences::GetDouble(kArmPKey, m_armKp)) {
-    m_armKp = wpi::Preferences::GetDouble(kArmPKey, m_armKp);
-    m_controller.SetP(m_armKp);
+  armSetpoint = wpi::units::degree_t{
+      wpi::Preferences::GetDouble(kArmPositionKey, armSetpoint.value())};
+  if (armKp != wpi::Preferences::GetDouble(kArmPKey, armKp)) {
+    armKp = wpi::Preferences::GetDouble(kArmPKey, armKp);
+    controller.SetP(armKp);
   }
 }
 
 void Arm::ReachSetpoint() {
   // Here, we run PID control like normal, with a setpoint read from
   // preferences in degrees.
-  double pidOutput = m_controller.Calculate(
-      m_encoder.GetDistance(), (wpi::units::radian_t{m_armSetpoint}.value()));
-  m_motor.SetVoltage(wpi::units::volt_t{pidOutput});
+  double pidOutput = controller.Calculate(
+      encoder.GetDistance(), (wpi::units::radian_t{armSetpoint}.value()));
+  motor.SetVoltage(wpi::units::volt_t{pidOutput});
 }
 
 void Arm::Stop() {
-  m_motor.SetThrottle(0.0);
+  motor.SetThrottle(0.0);
 }

wpilibcExamples/src/main/cpp/examples/ArmSimulation/include/Robot.hpp

@@ -20,6 +20,6 @@ class Robot : public wpi::TimedRobot {
   void DisabledInit() override;
 
  private:
-  wpi::Joystick m_joystick{kJoystickPort};
-  Arm m_arm;
+  wpi::Joystick joystick{kJoystickPort};
+  Arm arm;
 };

wpilibcExamples/src/main/cpp/examples/ArmSimulation/include/subsystems/Arm.hpp

@@ -29,23 +29,23 @@ class Arm {
 
  private:
   // The P gain for the PID controller that drives this arm.
-  double m_armKp = kDefaultArmKp;
-  wpi::units::degree_t m_armSetpoint = kDefaultArmSetpoint;
+  double armKp = kDefaultArmKp;
+  wpi::units::degree_t armSetpoint = kDefaultArmSetpoint;
 
   // The arm gearbox represents a gearbox containing two Vex 775pro motors.
-  wpi::math::DCMotor m_armGearbox = wpi::math::DCMotor::Vex775Pro(2);
+  wpi::math::DCMotor armGearbox = wpi::math::DCMotor::Vex775Pro(2);
 
   // Standard classes for controlling our arm
-  wpi::math::PIDController m_controller{m_armKp, 0, 0};
-  wpi::Encoder m_encoder{kEncoderAChannel, kEncoderBChannel};
-  wpi::PWMSparkMax m_motor{kMotorPort};
+  wpi::math::PIDController controller{armKp, 0, 0};
+  wpi::Encoder encoder{kEncoderAChannel, kEncoderBChannel};
+  wpi::PWMSparkMax motor{kMotorPort};
 
   // Simulation classes help us simulate what's going on, including gravity.
   // This sim represents an arm with 2 775s, a 600:1 reduction, a mass of 5kg,
   // 30in overall arm length, range of motion in [-75, 255] degrees, and noise
   // with a standard deviation of 1 encoder tick.
-  wpi::sim::SingleJointedArmSim m_armSim{
-      m_armGearbox,
+  wpi::sim::SingleJointedArmSim armSim{
+      armGearbox,
       kArmReduction,
       wpi::sim::SingleJointedArmSim::EstimateMOI(kArmLength, kArmMass),
       kArmLength,
@@ -54,16 +54,16 @@ class Arm {
       true,
       0_deg,
       {kArmEncoderDistPerPulse}};
-  wpi::sim::EncoderSim m_encoderSim{m_encoder};
+  wpi::sim::EncoderSim encoderSim{encoder};
 
   // Create a Mechanism2d display of an Arm
-  wpi::Mechanism2d m_mech2d{60, 60};
-  wpi::MechanismRoot2d* m_armBase = m_mech2d.GetRoot("ArmBase", 30, 30);
-  wpi::MechanismLigament2d* m_armTower =
-      m_armBase->Append<wpi::MechanismLigament2d>(
+  wpi::Mechanism2d mech2d{60, 60};
+  wpi::MechanismRoot2d* armBase = mech2d.GetRoot("ArmBase", 30, 30);
+  wpi::MechanismLigament2d* armTower =
+      armBase->Append<wpi::MechanismLigament2d>(
           "Arm Tower", 30, -90_deg, 6,
           wpi::util::Color8Bit{wpi::util::Color::BLUE});
-  wpi::MechanismLigament2d* m_arm = m_armBase->Append<wpi::MechanismLigament2d>(
-      "Arm", 30, m_armSim.GetAngle(), 6,
+  wpi::MechanismLigament2d* arm = armBase->Append<wpi::MechanismLigament2d>(
+      "Arm", 30, armSim.GetAngle(), 6,
       wpi::util::Color8Bit{wpi::util::Color::YELLOW});
 };

wpilibcExamples/src/main/cpp/examples/DifferentialDriveBot/cpp/Drivetrain.cpp

@@ -6,24 +6,24 @@
 
 void Drivetrain::SetVelocities(
     const wpi::math::DifferentialDriveWheelVelocities& velocities) {
-  const auto leftFeedforward = m_feedforward.Calculate(velocities.left);
-  const auto rightFeedforward = m_feedforward.Calculate(velocities.right);
-  const double leftOutput = m_leftPIDController.Calculate(
-      m_leftEncoder.GetRate(), velocities.left.value());
-  const double rightOutput = m_rightPIDController.Calculate(
-      m_rightEncoder.GetRate(), velocities.right.value());
+  const auto leftFeedforward = feedforward.Calculate(velocities.left);
+  const auto rightFeedforward = feedforward.Calculate(velocities.right);
+  const double leftOutput = leftPIDController.Calculate(
+      leftEncoder.GetRate(), velocities.left.value());
+  const double rightOutput = rightPIDController.Calculate(
+      rightEncoder.GetRate(), velocities.right.value());
 
-  m_leftLeader.SetVoltage(wpi::units::volt_t{leftOutput} + leftFeedforward);
-  m_rightLeader.SetVoltage(wpi::units::volt_t{rightOutput} + rightFeedforward);
+  leftLeader.SetVoltage(wpi::units::volt_t{leftOutput} + leftFeedforward);
+  rightLeader.SetVoltage(wpi::units::volt_t{rightOutput} + rightFeedforward);
 }
 
 void Drivetrain::Drive(wpi::units::meters_per_second_t xVelocity,
                        wpi::units::radians_per_second_t rot) {
-  SetVelocities(m_kinematics.ToWheelVelocities({xVelocity, 0_mps, rot}));
+  SetVelocities(kinematics.ToWheelVelocities({xVelocity, 0_mps, rot}));
 }
 
 void Drivetrain::UpdateOdometry() {
-  m_odometry.Update(m_imu.GetRotation2d(),
-                    wpi::units::meter_t{m_leftEncoder.GetDistance()},
-                    wpi::units::meter_t{m_rightEncoder.GetDistance()});
+  odometry.Update(imu.GetRotation2d(),
+                  wpi::units::meter_t{leftEncoder.GetDistance()},
+                  wpi::units::meter_t{rightEncoder.GetDistance()});
 }