[pre-commit.ci lite] apply automatic fixes

Author: pre-commit-ci-lite[bot]

src/shared/robot_constants.cpp

@@ -26,19 +26,19 @@ RobotConstants createRobotConstants()
         .dribbler_width_meters       = 0.07825f,
 
         // Dribbler speeds are negative as that is the direction that sucks the ball in
-        .indefinite_dribbler_speed_rpm = -10000,
-        .max_force_dribbler_speed_rpm  = -6000,
+        .indefinite_dribbler_speed_rpm   = -10000,
+        .max_force_dribbler_speed_rpm    = -6000,
         .release_ball_dribbler_speed_rpm = 0,
 
         // Motor constant
         .motor_max_acceleration_m_per_s_2 = 8.0f,
 
         // Robot's linear movement constants
-        .robot_max_speed_m_per_s            = 5.0f,
+        .robot_max_speed_m_per_s                  = 5.0f,
         .ball_placement_wall_max_speed_m_per_s    = 0.3f,
         .ball_placement_retreat_max_speed_m_per_s = 0.3f,
         .dribble_speed_m_per_s                    = 1.5f,
-        .robot_trajectory_max_speed_m_per_s = 3.5f,
+        .robot_trajectory_max_speed_m_per_s       = 3.5f,
 
         .robot_max_acceleration_m_per_s_2 = 4.0f,
         .robot_max_deceleration_m_per_s_2 = 4.0f,

src/software/ai/navigator/trajectory/jerk_limited_trajectory_1d.cpp

@@ -37,19 +37,20 @@ void JerkLimitedTrajectory1D::generate(const double initial_pos, const double fi
         return;
     }
 
-    // Note: if we are already at the target but still moving, we intentionally do not stop
-    // here. Doing so would leave the robot wherever its momentum carries it rather than at
-    // the destination. Instead we fall through to the logic below, which will overshoot the
-    // target and then plan a trajectory back to it.
+    // Note: if we are already at the target but still moving, we intentionally do not
+    // stop here. Doing so would leave the robot wherever its momentum carries it rather
+    // than at the destination. Instead we fall through to the logic below, which will
+    // overshoot the target and then plan a trajectory back to it.
 
     // Ramp the initial acceleration to zero via a preliminary jerk phase, then plan the
     // rest of the trajectory from that zero-acceleration state. The 2D layer feeds the
     // robot's actual (unscaled) initial acceleration into each axis while scaling the
-    // per-axis acceleration/jerk limits, so the initial acceleration can exceed or conflict
-    // with those limits. The planning primitives below (planAccelProfile, planDecelToStop,
-    // planDecelToSpeed) are only well-defined for a zero initial acceleration; feeding them
-    // an out-of-range initial acceleration produces inconsistent profiles (e.g. negative
-    // phase durations) that fail to reach the destination.
+    // per-axis acceleration/jerk limits, so the initial acceleration can exceed or
+    // conflict with those limits. The planning primitives below (planAccelProfile,
+    // planDecelToStop, planDecelToSpeed) are only well-defined for a zero initial
+    // acceleration; feeding them an out-of-range initial acceleration produces
+    // inconsistent profiles (e.g. negative phase durations) that fail to reach the
+    // destination.
     double t = 0.0, p = 0.0, v = initial_vel, a = initial_accel;
     if (std::abs(a) > EPSILON)
     {
@@ -492,12 +493,12 @@ void JerkLimitedTrajectory1D::generateDirect(
 
     // Plan the phase that brings the robot from its initial velocity to signed_peak. We
     // accelerate if the peak is above the initial speed, but decelerate if the initial
-    // speed already exceeds the peak (which happens when a scaled 2D axis velocity limit is
-    // smaller than the robot's initial speed component along that axis). Previously this
-    // always used planAccelProfile, which returns an empty plan when the initial speed is
-    // already above the peak. The robot would then never slow down to the cruise speed, so
-    // the cruise/deceleration distances were computed for the peak speed while the robot
-    // was actually travelling faster, causing it to overshoot the destination.
+    // speed already exceeds the peak (which happens when a scaled 2D axis velocity limit
+    // is smaller than the robot's initial speed component along that axis). Previously
+    // this always used planAccelProfile, which returns an empty plan when the initial
+    // speed is already above the peak. The robot would then never slow down to the cruise
+    // speed, so the cruise/deceleration distances were computed for the peak speed while
+    // the robot was actually travelling faster, causing it to overshoot the destination.
     auto planToPeak = [&](const double signed_peak)
     {
         if (std::abs(signed_peak) >= std::abs(initial_vel))

src/software/ai/navigator/trajectory/jerk_limited_trajectory_1d.h

@@ -58,7 +58,8 @@ class JerkLimitedTrajectory1D : public Trajectory<double, double, double>
     // Decelerate from the initial speed down to a lower target speed (in the same
     // direction of travel as initial_vel). This is the mirror of planAccelProfile for the
     // case where the initial speed already exceeds the desired peak/cruise speed, which
-    // can happen when a 2D axis limit is scaled below the robot's initial speed component.
+    // can happen when a 2D axis limit is scaled below the robot's initial speed
+    // component.
     static AccelPlan planDecelToSpeed(double initial_vel, double initial_accel,
                                       double target_speed, double max_jerk,
                                       double min_jerk, double max_decel);

src/software/embedded/motion_control/position_controller.h

@@ -28,7 +28,8 @@ class PositionController : public MotionController<Point, TrajectoryPath, Vector
      *
      * @param config The PID gains to use for the underlying x/y PID controllers.
      */
-    explicit PositionController(const PositionControllerConfig& config = PositionControllerConfig());
+    explicit PositionController(
+        const PositionControllerConfig& config = PositionControllerConfig());
 
     /**
      * Given a position and target trajectory, returns a target global velocity to

src/software/embedded/primitive_executor.cpp

@@ -349,10 +349,14 @@ Vector PrimitiveExecutor::stepTargetLinearVelocity(const Duration& delta_time)
     //                                              {"target_pos_y", target_position.y()},
     //                                              {"target_vel_x", target_v_global.x()},
     //                                              {"target_vel_y", target_v_global.y()},
-    //                                              {"actual_pos_x", state_.position().x()},
-    //                                              {"actual_pos_y", state_.position().y()},
-    //                                              {"actual_vel_x", state_.velocity().x()},
-    //                                              {"actual_vel_y", state_.velocity().y()},
+    //                                              {"actual_pos_x",
+    //                                              state_.position().x()},
+    //                                              {"actual_pos_y",
+    //                                              state_.position().y()},
+    //                                              {"actual_vel_x",
+    //                                              state_.velocity().x()},
+    //                                              {"actual_vel_y",
+    //                                              state_.velocity().y()},
     //                                              {"traj_vel_x", target_velocity.x()},
     //                                              {"traj_vel_y", target_velocity.y()}});
 

src/software/embedded/thunderloop.cpp

@@ -84,21 +84,21 @@ Thunderloop::Thunderloop(const robot_constants::RobotConstants& robot_constants,
       primitive_executor_(
           robot_constants,
           PositionControllerConfig{
-              std::stod(toml_config_client_->get(
-                  ROBOT_POSITION_CONTROLLER_KP_CONFIG_KEY)),
-              std::stod(toml_config_client_->get(
-                  ROBOT_POSITION_CONTROLLER_KI_CONFIG_KEY)),
-              std::stod(toml_config_client_->get(
-                  ROBOT_POSITION_CONTROLLER_KD_CONFIG_KEY)),
+              std::stod(
+                  toml_config_client_->get(ROBOT_POSITION_CONTROLLER_KP_CONFIG_KEY)),
+              std::stod(
+                  toml_config_client_->get(ROBOT_POSITION_CONTROLLER_KI_CONFIG_KEY)),
+              std::stod(
+                  toml_config_client_->get(ROBOT_POSITION_CONTROLLER_KD_CONFIG_KEY)),
               std::stod(toml_config_client_->get(
                   ROBOT_POSITION_CONTROLLER_MAX_INTEGRAL_CONFIG_KEY))},
           OrientationControllerConfig{
-              std::stod(toml_config_client_->get(
-                  ROBOT_ORIENTATION_CONTROLLER_KP_CONFIG_KEY)),
-              std::stod(toml_config_client_->get(
-                  ROBOT_ORIENTATION_CONTROLLER_KI_CONFIG_KEY)),
-              std::stod(toml_config_client_->get(
-                  ROBOT_ORIENTATION_CONTROLLER_KD_CONFIG_KEY)),
+              std::stod(
+                  toml_config_client_->get(ROBOT_ORIENTATION_CONTROLLER_KP_CONFIG_KEY)),
+              std::stod(
+                  toml_config_client_->get(ROBOT_ORIENTATION_CONTROLLER_KI_CONFIG_KEY)),
+              std::stod(
+                  toml_config_client_->get(ROBOT_ORIENTATION_CONTROLLER_KD_CONFIG_KEY)),
               std::stod(toml_config_client_->get(
                   ROBOT_ORIENTATION_CONTROLLER_MAX_INTEGRAL_CONFIG_KEY))}),
       robot_localizer_(RobotLocalizer::RobotLocalizerConfig{

src/software/embedded/toml_config/toml_config_client.cpp

@@ -89,7 +89,8 @@ void TomlConfigClient::writeConfig()
     has_pending_changes_ = false;
 }
 
-std::string TomlConfigClient::get(const std::string& key, const std::string& default_value)
+std::string TomlConfigClient::get(const std::string& key,
+                                  const std::string& default_value)
 {
     std::lock_guard<std::mutex> lock(config_mutex_);