Update C++ Simulation to match Java (#1026)

photonlib-cpp-examples/swervedriveposeestsim/src/main/cpp/Robot.cpp

@@ -0,0 +1,123 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) PhotonVision
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "Robot.h"
+
+#include <iostream>
+
+#include <frc/simulation/BatterySim.h>
+#include <frc/simulation/RoboRioSim.h>
+
+void Robot::RobotInit() {}
+
+void Robot::RobotPeriodic() {
+  drivetrain.Periodic();
+
+  auto visionEst = vision.GetEstimatedGlobalPose();
+  if (visionEst.has_value()) {
+    auto est = visionEst.value();
+    auto estPose = est.estimatedPose.ToPose2d();
+    auto estStdDevs = vision.GetEstimationStdDevs(estPose);
+    drivetrain.AddVisionMeasurement(est.estimatedPose.ToPose2d(), est.timestamp,
+                                    estStdDevs);
+  }
+
+  drivetrain.Log();
+}
+
+void Robot::DisabledInit() {}
+
+void Robot::DisabledPeriodic() { drivetrain.Stop(); }
+
+void Robot::DisabledExit() {}
+
+void Robot::AutonomousInit() {
+  autoTimer.Restart();
+  frc::Pose2d pose{1_m, 1_m, frc::Rotation2d{}};
+  drivetrain.ResetPose(pose, true);
+}
+
+void Robot::AutonomousPeriodic() {
+  if (autoTimer.Get() < 10_s) {
+    drivetrain.Drive(0.5_mps, 0.5_mps, 0.5_rad_per_s, false);
+  } else {
+    autoTimer.Stop();
+    drivetrain.Stop();
+  }
+}
+
+void Robot::AutonomousExit() {}
+
+void Robot::TeleopInit() {}
+
+void Robot::TeleopPeriodic() {
+  double forward = -controller.GetLeftY() * kDriveSpeed;
+  if (std::abs(forward) < 0.1) {
+    forward = 0;
+  }
+  forward = forwardLimiter.Calculate(forward);
+
+  double strafe = -controller.GetLeftX() * kDriveSpeed;
+  if (std::abs(strafe) < 0.1) {
+    strafe = 0;
+  }
+  strafe = strafeLimiter.Calculate(strafe);
+
+  double turn = -controller.GetRightX() * kDriveSpeed;
+  if (std::abs(turn) < 0.1) {
+    turn = 0;
+  }
+  turn = turnLimiter.Calculate(turn);
+
+  drivetrain.Drive(forward * constants::Swerve::kMaxLinearSpeed,
+                   strafe * constants::Swerve::kMaxLinearSpeed,
+                   turn * constants::Swerve::kMaxAngularSpeed, true);
+}
+
+void Robot::TeleopExit() {}
+
+void Robot::TestInit() {}
+
+void Robot::TestPeriodic() {}
+
+void Robot::TestExit() {}
+
+void Robot::SimulationPeriodic() {
+  drivetrain.SimulationPeriodic();
+  vision.SimPeriodic(drivetrain.GetSimPose());
+
+  frc::Field2d& debugField = vision.GetSimDebugField();
+  debugField.GetObject("EstimatedRobot")->SetPose(drivetrain.GetPose());
+  debugField.GetObject("EstimatedRobotModules")
+      ->SetPoses(drivetrain.GetModulePoses());
+
+  units::ampere_t totalCurrent = drivetrain.GetCurrentDraw();
+  units::volt_t loadedBattVolts =
+      frc::sim::BatterySim::Calculate({totalCurrent});
+  frc::sim::RoboRioSim::SetVInVoltage(loadedBattVolts);
+}
+
+#ifndef RUNNING_FRC_TESTS
+int main() { return frc::StartRobot<Robot>(); }
+#endif