links

Author: Py-mon

docs/index.md

@@ -10,7 +10,7 @@ Black Ice (by FTC Team #18535, Frozen Code) is a **reactive + predictive path fo
 
 It drives at **high speeds** and then brakes up to **5× faster** than other libraries.
 
-Black Ice achieves this by using [**quadratic-damped PIDs**](https://github.com/TeamFrozenCodeFTC/Black-Ice-Path-Follower/blob/main/TeamCode/src/main/java/org/firstinspires/ftc/blackice/docs/quadratic-damping-pid.md#our-key-innovation-the-quadratic-damped-pid), which model nonlinear friction and resistance. This lets it accurately predict stopping behavior at any speed, preventing the overshoot and undershoot common with aggressive PIDs that don't account for friction while braking. This allows much **faster**, more **accurate**, and more **responsive** control by braking to a stop rather than coasting to a stop like other libraries such as Roadrunner or Pedro Path.
+Black Ice achieves this by using [**quadratic-damped PIDs**](https://teamfrozencodeftc.github.io/Black-Ice-Path-Follower/quadratic-damped-pid.html), which model nonlinear friction and resistance. This lets it accurately predict stopping behavior at any speed, preventing the overshoot and undershoot common with aggressive PIDs that don't account for friction while braking. This allows much **faster**, more **accurate**, and more **responsive** control by braking to a stop rather than coasting to a stop like other libraries such as Roadrunner or Pedro Path.
 
 ## How much difference does the Quadratic Damping make?
 Other libraries (e.g. Roadrunner, Pedro Path) rely on gentle PID + coasting:

docs/path-follower-evolution.md

@@ -43,13 +43,11 @@ Initially, the robot overshot because braking occurred only after reaching the t
 
 We commonly found our coefficients to be around `a=0.001` and `b=0.07`.
 
-- The `a` term accounts for friction and momentum when braking. This makes it much more accurate at high velocities when friction is more dominant than the wheels' braking force.
+- The `a` term accounts for the non-linear affects of friction when braking. This makes it much more accurate at high velocities when friction is more dominant than the wheels' braking force. Learn more about [why the braking distance is non-linear here.](https://teamfrozencodeftc.github.io/Black-Ice-Path-Follower/quadratic-damped-pid.html#why-is-the-braking-non-linear)
 - the `b` term is basically the robot's braking force from the wheels. Later on, we would realize that this term was just a more empirical version of the derivative term in PIDs.
 
 In this prototype version, it would just turn on zero power brake mode if the distance was greater than the distance remaining to the target point. This worked okay, but it could not correct while it was braking. In next prototype version we would fix this issue by turning it into a simple proportional controller.
 
-[Why is the Braking Distance Non-Linear?](https://github.com/TeamFrozenCodeFTC/Black-Ice-Path-Follower/blob/main/TeamCode/src/main/java/org/firstinspires/ftc/blackice/docs/quadratic-damping-pid.md#why-is-the-braking-non-linear)
-
 ## v3.0 - Corrective Braking Using a Quadratic-Damped PID
 ###### Final version used in the 2024–2025 season, first called Black-Ice at our second competition, and also used at our state championship.
 {: .no_toc}
@@ -64,7 +62,7 @@ predictedPositionAfterBraking = current + predictedBrakingDisplacement
 error = target - predictedPositionAfterBraking
 power = error * proportionalConstant
 ```
-We later would realize that this is just a more empirical version of a [PID controller with quadratic damping](https://github.com/TeamFrozenCodeFTC/Black-Ice-Path-Follower/edit/main/TeamCode/src/main/java/org/firstinspires/ftc/blackice/docs/path-follower-evolution.md#predictivebrakingcontroller--empirical-pid-controller-with-quadratic-damping). The `b` is just the derivative term, and the `a` is the quadratic damping.
+We later would realize that this is just a more empirical version of a [PID controller with quadratic damping](https://teamfrozencodeftc.github.io/Black-Ice-Path-Follower/path-follower-evolution.html#predictivebrakingcontroller--empirical-pid-controller-with-quadratic-damping). The `b` is just the derivative term, and the `a` is the quadratic damping.
 
 **Fun Fact:** We originally thought our algorithm was falling apart here because it would be quite a few inches off from the target, so we tried adding Integral terms but eventually we figured out that one of our odometry pods was just defective.
 

docs/quadratic-damped-pid.md

@@ -7,7 +7,7 @@ nav_order: 3
 # Our Key Innovation, the Quadratic-Damped PID
 
 Our key innovation about our follower is our quadratic-damped PID. We include this quadratic damping term in our translational PID, allowing it to be nearly **5x faster** at decelerating, more aggressive, and accurate while minimizing premature deceleration for faster deceleration. 
-You can learn about how we came up with this idea with [our first empirical approach](https://github.com/TeamFrozenCodeFTC/Black-Ice-Path-Follower/blob/main/TeamCode/src/main/java/org/firstinspires/ftc/blackice/docs/path-follower-evolution.md#v30---corrective-braking-using-a-quadratic-damped-pid)
+You can learn about how we came up with this idea with [our first empirical approach](https://teamfrozencodeftc.github.io/Black-Ice-Path-Follower/path-follower-evolution.html#v30---corrective-braking-using-a-quadratic-damped-pid)
 
 Pseudo code of PD controller with quadratic damping
 ```
@@ -50,19 +50,27 @@ With quadratic damping + back-EMF braking:
 ## How does -velocity = Derivative term in PID?
 Let the positional error be:  
 
-$error = target_{pos} - current_{pos}$
+```math
+error = target_{pos} - current_{pos}
+```
 
 Taking the derivative of both sides:  
 
-$\frac{d}{dt}(error) = \frac{d}{dt}(target_{pos}) - \frac{d}{dt}(current_{pos})$
+```math
+\frac{d}{dt}(error) = \frac{d}{dt}(target_{pos}) - \frac{d}{dt}(current_{pos})
+```
 
 If the target position is constant, then:  
 
-$\frac{d}{dt}(\text{target}_{\text{pos}}) = 0$
+```math
+\frac{d}{dt}(\text{target}_{\text{pos}}) = 0
+```
 
 Then:  
 
-$\frac{d}{dt}(error) = -\frac{d}{dt}(current_{pos}) = -velocity$
+```math
+\frac{d}{dt}(error) = -\frac{d}{dt}(current_{pos}) = -velocity
+```
 
 Therefore, when the target position is fixed, the derivative of the position error is simply the **negative of the current velocity**.