diff --git a/frc971/control_loops/drivetrain/drivetrain_test_lib.cc b/frc971/control_loops/drivetrain/drivetrain_test_lib.cc
index 7617dc2..5df1666 100644
--- a/frc971/control_loops/drivetrain/drivetrain_test_lib.cc
+++ b/frc971/control_loops/drivetrain/drivetrain_test_lib.cc
@@ -111,8 +111,7 @@
   drivetrain_plant_.mutable_X(1, 0) = 0.0;
   drivetrain_plant_.mutable_X(2, 0) = 0.0;
   drivetrain_plant_.mutable_X(3, 0) = 0.0;
-  drivetrain_plant_.mutable_Y() =
-      drivetrain_plant_.C() * drivetrain_plant_.X();
+  drivetrain_plant_.mutable_Y() = drivetrain_plant_.C() * drivetrain_plant_.X();
   last_left_position_ = drivetrain_plant_.Y(0, 0);
   last_right_position_ = drivetrain_plant_.Y(1, 0);
 }
@@ -134,8 +133,8 @@
   {
     ::aos::ScopedMessagePtr<::frc971::sensors::GyroReading> gyro =
         gyro_reading_.MakeMessage();
-    gyro->angle = (right_encoder - left_encoder) /
-                  (dt_config_.robot_radius * 2.0);
+    gyro->angle =
+        (right_encoder - left_encoder) / (dt_config_.robot_radius * 2.0);
     gyro->velocity = (drivetrain_plant_.X(3, 0) - drivetrain_plant_.X(1, 0)) /
                      (dt_config_.robot_radius * 2.0);
     gyro.Send();
@@ -177,10 +176,7 @@
   U(0, 0) += drivetrain_plant_.left_voltage_offset();
   U(1, 0) += drivetrain_plant_.right_voltage_offset();
   drivetrain_plant_.Update(U);
-  double dt_float =
-      ::std::chrono::duration_cast<::std::chrono::duration<double>>(
-          dt_config_.dt)
-          .count();
+  double dt_float = ::aos::time::DurationInSeconds(dt_config_.dt);
   state_ = RungeKuttaU(
       [this](const ::Eigen::Matrix<double, 5, 1> &X,
              const ::Eigen::Matrix<double, 2, 1> &U) {
diff --git a/frc971/control_loops/drivetrain/hybrid_ekf.h b/frc971/control_loops/drivetrain/hybrid_ekf.h
index 5cecce7..68f67f6 100644
--- a/frc971/control_loops/drivetrain/hybrid_ekf.h
+++ b/frc971/control_loops/drivetrain/hybrid_ekf.h
@@ -3,12 +3,12 @@
 
 #include <chrono>
 
+#include "Eigen/Dense"
 #include "aos/containers/priority_queue.h"
 #include "aos/util/math.h"
 #include "frc971/control_loops/c2d.h"
-#include "frc971/control_loops/runge_kutta.h"
-#include "Eigen/Dense"
 #include "frc971/control_loops/drivetrain/drivetrain_config.h"
+#include "frc971/control_loops/runge_kutta.h"
 
 namespace y2019 {
 namespace control_loops {
@@ -50,7 +50,7 @@
     kRightEncoder = 5,
     kRightVelocity = 6,
     kLeftVoltageError = 7,
-    kRightVoltageError = 8 ,
+    kRightVoltageError = 8,
     kAngularError = 9,
   };
   static constexpr int kNStates = 10;
@@ -140,10 +140,12 @@
           void(const State &, const StateSquare &,
                ::std::function<Output(const State &, const Input &)> *,
                ::std::function<Eigen::Matrix<Scalar, kNOutputs, kNStates>(
-                   const State &)> *)> make_h,
+                   const State &)> *)>
+          make_h,
       ::std::function<Output(const State &, const Input &)> h,
       ::std::function<Eigen::Matrix<Scalar, kNOutputs, kNStates>(const State &)>
-          dhdx, const Eigen::Matrix<Scalar, kNOutputs, kNOutputs> &R,
+          dhdx,
+      const Eigen::Matrix<Scalar, kNOutputs, kNOutputs> &R,
       aos::monotonic_clock::time_point t);
 
   // A utility function for specifically updating with encoder and gyro
@@ -177,9 +179,10 @@
     Eigen::Matrix<Scalar, kNOutputs, kNOutputs> R;
     R.setZero();
     R.diagonal() << encoder_noise_, encoder_noise_, gyro_noise_;
-    Correct(z, &U, {}, [this](const State &X, const Input &) {
-                         return H_encoders_and_gyro_ * X;
-                       },
+    Correct(z, &U, {},
+            [this](const State &X, const Input &) {
+              return H_encoders_and_gyro_ * X;
+            },
             [this](const State &) { return H_encoders_and_gyro_; }, R, t);
   }
 
@@ -210,11 +213,12 @@
     // estimate. This is used by the camera to make it so that we only have to
     // match targets once.
     // Only called if h and dhdx are empty.
-    ::std::function<
-        void(const State &, const StateSquare &,
-             ::std::function<Output(const State &, const Input &)> *,
-             ::std::function<Eigen::Matrix<Scalar, kNOutputs, kNStates>(
-                 const State &)> *)> make_h;
+    ::std::function<void(
+        const State &, const StateSquare &,
+        ::std::function<Output(const State &, const Input &)> *,
+        ::std::function<Eigen::Matrix<Scalar, kNOutputs, kNStates>(
+            const State &)> *)>
+        make_h;
     // A function to calculate the expected output at a given state/input.
     // TODO(james): For encoders/gyro, it is linear and the function call may
     // be expensive. Potential source of optimization.
@@ -226,14 +230,14 @@
     // recalculate it to be strictly correct, but I was both too lazy to do
     // so and it seemed unnecessary). This is a potential source for future
     // optimizations if function calls are being expensive.
-    ::std::function<
-        Eigen::Matrix<Scalar, kNOutputs, kNStates>(const State &)> dhdx;
+    ::std::function<Eigen::Matrix<Scalar, kNOutputs, kNStates>(const State &)>
+        dhdx;
     // The measurement noise matrix.
     Eigen::Matrix<Scalar, kNOutputs, kNOutputs> R;
 
     // In order to sort the observations in the PriorityQueue object, we
     // need a comparison function.
-    friend bool operator <(const Observation &l, const Observation &r) {
+    friend bool operator<(const Observation &l, const Observation &r) {
       return l.t < r.t;
     }
   };
@@ -278,11 +282,8 @@
     controls::DiscretizeQAFast(Q_continuous_, A_c, dt, &Q_d, &A_d);
 
     *state = RungeKuttaU(
-        [this](const State &X,
-               const Input &U) { return DiffEq(X, U); },
-        *state, U,
-        ::std::chrono::duration_cast<::std::chrono::duration<double>>(dt)
-            .count());
+        [this](const State &X, const Input &U) { return DiffEq(X, U); }, *state,
+        U, ::aos::time::DurationInSeconds(dt));
 
     StateSquare Ptemp = A_d * *P * A_d.transpose() + Q_d;
     *P = Ptemp;
@@ -342,11 +343,13 @@
     ::std::function<
         void(const State &, const StateSquare &,
              ::std::function<Output(const State &, const Input &)> *,
-             ::std::function<Eigen::Matrix<Scalar, kNOutputs, kNStates>(
-                 const State &)> *)> make_h,
+             ::std::function<
+                 Eigen::Matrix<Scalar, kNOutputs, kNStates>(const State &)> *)>
+        make_h,
     ::std::function<Output(const State &, const Input &)> h,
     ::std::function<Eigen::Matrix<Scalar, kNOutputs, kNStates>(const State &)>
-        dhdx, const Eigen::Matrix<Scalar, kNOutputs, kNOutputs> &R,
+        dhdx,
+    const Eigen::Matrix<Scalar, kNOutputs, kNOutputs> &R,
     aos::monotonic_clock::time_point t) {
   CHECK(!observations_.empty());
   if (!observations_.full() && t < observations_.begin()->t) {
@@ -362,10 +365,9 @@
     LOG(DEBUG,
         "Camera dropped off of end with time of %fs; earliest observation in "
         "queue has time of %fs.\n",
-        ::std::chrono::duration_cast<::std::chrono::duration<double>>(
-            t.time_since_epoch()).count(),
-        ::std::chrono::duration_cast<::std::chrono::duration<double>>(
-            observations_.begin()->t.time_since_epoch()).count());
+        ::aos::time::DurationInSeconds(t.time_since_epoch()),
+        ::aos::time::DurationInSeconds(
+            observations_.begin()->t.time_since_epoch()));
     return;
   }
 
diff --git a/frc971/control_loops/drivetrain/hybrid_ekf_test.cc b/frc971/control_loops/drivetrain/hybrid_ekf_test.cc
index 80ce95c..fa6acc5 100644
--- a/frc971/control_loops/drivetrain/hybrid_ekf_test.cc
+++ b/frc971/control_loops/drivetrain/hybrid_ekf_test.cc
@@ -4,8 +4,8 @@
 
 #include "aos/testing/random_seed.h"
 #include "aos/testing/test_shm.h"
-#include "frc971/control_loops/drivetrain/trajectory.h"
 #include "frc971/control_loops/drivetrain/drivetrain_test_lib.h"
+#include "frc971/control_loops/drivetrain/trajectory.h"
 #include "gtest/gtest.h"
 
 namespace frc971 {
@@ -15,7 +15,6 @@
 
 typedef HybridEkf<>::StateIdx StateIdx;
 
-
 class HybridEkfTest : public ::testing::Test {
  public:
   typedef HybridEkf<>::State State;
@@ -37,8 +36,7 @@
     return RungeKuttaU(
         ::std::bind(&HybridEkfTest::DiffEq, this, ::std::placeholders::_1,
                     ::std::placeholders::_2),
-        X, U, ::std::chrono::duration_cast<::std::chrono::duration<double>>(
-                  dt_config_.dt).count());
+        X, U, ::aos::time::DurationInSeconds(dt_config_.dt));
   }
   void CheckDiffEq(const State &X, const Input &U) {
     // Re-implement dynamics as a sanity check:
@@ -69,15 +67,11 @@
     // Dynamics don't expect error terms to change:
     EXPECT_EQ(0.0, Xdot_ekf.bottomRows<3>().squaredNorm());
   }
-  State DiffEq(const State &X, const Input &U) {
-    return ekf_.DiffEq(X, U);
-  }
+  State DiffEq(const State &X, const Input &U) { return ekf_.DiffEq(X, U); }
 
   // Returns a random value sampled from a normal distribution with a standard
   // deviation of std and a mean of zero.
-  double Normal(double std) {
-    return normal_(gen_) * std;
-  }
+  double Normal(double std) { return normal_(gen_) * std; }
 
   DrivetrainConfig<double> dt_config_;
   HybridEkf<> ekf_;
@@ -93,19 +87,23 @@
   CheckDiffEq(State::Zero(), Input::Zero());
   CheckDiffEq(State::Zero(), {-5.0, 5.0});
   CheckDiffEq(State::Zero(), {12.0, -3.0});
-  CheckDiffEq((State() << 100.0, 200.0, M_PI, 1.234, 0.5, 1.2, 0.6, 3.0, -4.0,
-               0.3).finished(),
-              {5.0, 6.0});
-  CheckDiffEq((State() << 100.0, 200.0, 2.0, 1.234, 0.5, 1.2, 0.6, 3.0, -4.0,
-               0.3).finished(),
-              {5.0, 6.0});
-  CheckDiffEq((State() << 100.0, 200.0, -2.0, 1.234, 0.5, 1.2, 0.6, 3.0, -4.0,
-               0.3).finished(),
-              {5.0, 6.0});
+  CheckDiffEq(
+      (State() << 100.0, 200.0, M_PI, 1.234, 0.5, 1.2, 0.6, 3.0, -4.0, 0.3)
+          .finished(),
+      {5.0, 6.0});
+  CheckDiffEq(
+      (State() << 100.0, 200.0, 2.0, 1.234, 0.5, 1.2, 0.6, 3.0, -4.0, 0.3)
+          .finished(),
+      {5.0, 6.0});
+  CheckDiffEq(
+      (State() << 100.0, 200.0, -2.0, 1.234, 0.5, 1.2, 0.6, 3.0, -4.0, 0.3)
+          .finished(),
+      {5.0, 6.0});
   // And check that a theta outisde of [-M_PI, M_PI] works.
-  CheckDiffEq((State() << 100.0, 200.0, 200.0, 1.234, 0.5, 1.2, 0.6, 3.0, -4.0,
-               0.3).finished(),
-              {5.0, 6.0});
+  CheckDiffEq(
+      (State() << 100.0, 200.0, 200.0, 1.234, 0.5, 1.2, 0.6, 3.0, -4.0, 0.3)
+          .finished(),
+      {5.0, 6.0});
 }
 
 // Tests that if we provide a bunch of observations of the position
@@ -232,7 +230,7 @@
   expected_X_hat(1, 0) = Z(1, 0) + modeled_X_hat(0, 0);
   expected_X_hat(2, 0) = Z(2, 0);
   EXPECT_LT((expected_X_hat.topRows<7>() - ekf_.X_hat().topRows<7>()).norm(),
-           1e-3)
+            1e-3)
       << "X_hat: " << ekf_.X_hat() << " expected " << expected_X_hat;
   // The covariance after the predictions but before the corrections should
   // be higher than after the corrections are made.
@@ -299,7 +297,9 @@
                                U, t0_ + (ii + 1) * dt_config_.dt);
     EXPECT_NEAR((true_X - ekf_.X_hat()).squaredNorm(), 0.0, 1e-25)
         << "Expected only floating point precision errors in update step. "
-           "Estimated X_hat:\n" << ekf_.X_hat() << "\ntrue X:\n" << true_X;
+           "Estimated X_hat:\n"
+        << ekf_.X_hat() << "\ntrue X:\n"
+        << true_X;
   }
 }
 
@@ -373,14 +373,17 @@
         true_X(StateIdx::kRightEncoder, 0) + Normal(1e-3),
         (true_X(StateIdx::kRightVelocity, 0) -
          true_X(StateIdx::kLeftVelocity, 0)) /
-            dt_config_.robot_radius / 2.0 + Normal(1e-4),
+                dt_config_.robot_radius / 2.0 +
+            Normal(1e-4),
         U, t0_ + (ii + 1) * dt_config_.dt);
   }
   EXPECT_NEAR(
       (true_X.bottomRows<9>() - ekf_.X_hat().bottomRows<9>()).squaredNorm(),
       0.0, 2e-3)
       << "Expected non-x/y estimates to converge to correct. "
-         "Estimated X_hat:\n" << ekf_.X_hat() << "\ntrue X:\n" << true_X;
+         "Estimated X_hat:\n"
+      << ekf_.X_hat() << "\ntrue X:\n"
+      << true_X;
 }
 
 class HybridEkfDeathTest : public HybridEkfTest {};
diff --git a/frc971/control_loops/drivetrain/line_follow_drivetrain_test.cc b/frc971/control_loops/drivetrain/line_follow_drivetrain_test.cc
index 414ec81..7d401d6 100644
--- a/frc971/control_loops/drivetrain/line_follow_drivetrain_test.cc
+++ b/frc971/control_loops/drivetrain/line_follow_drivetrain_test.cc
@@ -63,7 +63,6 @@
       EXPECT_EQ(0.0, output.right_voltage);
     }
 
-
     EXPECT_LE(::std::abs(output.left_voltage), 12.0 + 1e-6);
     EXPECT_LE(::std::abs(output.right_voltage), 12.0 + 1e-6);
 
@@ -75,12 +74,10 @@
           return ContinuousDynamics(velocity_drivetrain_->plant(), Tlr_to_la_,
                                     X, U);
         },
-        state_, U,
-        chrono::duration_cast<chrono::duration<double>>(config_.dt).count());
+        state_, U, ::aos::time::DurationInSeconds(config_.dt));
     t_ += config_.dt;
 
-    time_.push_back(chrono::duration_cast<chrono::duration<double>>(
-                        t_.time_since_epoch()).count());
+    time_.push_back(::aos::time::DurationInSeconds(t_.time_since_epoch()));
     simulation_ul_.push_back(U(0, 0));
     simulation_ur_.push_back(U(1, 0));
     simulation_x_.push_back(state_.x());
@@ -350,16 +347,15 @@
                 .finished(),
             (::Eigen::Matrix<double, 5, 1>() << -2.0, -1.0, 0.0, 0.5, -0.5)
                 .finished()),
-        ::testing::Values(
-            [](const ::Eigen::Matrix<double, 5, 1> &state) {
-              return -1.0 * state.x();
-            },
-            [](const ::Eigen::Matrix<double, 5, 1> &state) {
-              return 1.0 * state.x();
-            },
-            [](const ::Eigen::Matrix<double, 5, 1> &state) {
-              return -0.25 * ::std::abs(state.x()) - 0.125 * state.x() * state.x();
-            })));
+        ::testing::Values([](const ::Eigen::Matrix<double, 5, 1>
+                                 &state) { return -1.0 * state.x(); },
+                          [](const ::Eigen::Matrix<double, 5, 1> &state) {
+                            return 1.0 * state.x();
+                          },
+                          [](const ::Eigen::Matrix<double, 5, 1> &state) {
+                            return -0.25 * ::std::abs(state.x()) -
+                                   0.125 * state.x() * state.x();
+                          })));
 
 }  // namespace testing
 }  // namespace drivetrain
diff --git a/frc971/control_loops/drivetrain/trajectory.cc b/frc971/control_loops/drivetrain/trajectory.cc
index c9582e6..ae51cb1 100644
--- a/frc971/control_loops/drivetrain/trajectory.cc
+++ b/frc971/control_loops/drivetrain/trajectory.cc
@@ -4,8 +4,8 @@
 
 #include "Eigen/Dense"
 #include "aos/logging/matrix_logging.h"
-#include "frc971/control_loops/dlqr.h"
 #include "frc971/control_loops/c2d.h"
+#include "frc971/control_loops/dlqr.h"
 #include "frc971/control_loops/drivetrain/distance_spline.h"
 #include "frc971/control_loops/drivetrain/drivetrain_config.h"
 #include "frc971/control_loops/hybrid_state_feedback_loop.h"
@@ -259,7 +259,6 @@
 
 ::Eigen::Matrix<double, 5, 5> Trajectory::ALinearizedContinuous(
     const ::Eigen::Matrix<double, 5, 1> &state) const {
-
   const double sintheta = ::std::sin(state(2));
   const double costheta = ::std::cos(state(2));
   const ::Eigen::Matrix<double, 2, 1> linear_angular =
@@ -268,7 +267,7 @@
   // When stopped, just roll with a min velocity.
   double linear_velocity = 0.0;
   constexpr double kMinVelocity = 0.1;
-  if (::std::abs(linear_angular(0)) < kMinVelocity / 100.0)  {
+  if (::std::abs(linear_angular(0)) < kMinVelocity / 100.0) {
     linear_velocity = 0.1;
   } else if (::std::abs(linear_angular(0)) > kMinVelocity) {
     linear_velocity = linear_angular(0);
@@ -312,8 +311,7 @@
       BLinearizedContinuous();
 
   // Now, convert it to discrete.
-  controls::C2D(A_linearized_continuous, B_linearized_continuous,
-                dt, A, B);
+  controls::C2D(A_linearized_continuous, B_linearized_continuous, dt, A, B);
 }
 
 ::Eigen::Matrix<double, 2, 5> Trajectory::KForState(
@@ -355,24 +353,25 @@
   result.block<2, 1>(0, 0) = spline_->XY(distance);
   result(2, 0) = spline_->Theta(distance);
 
-  result.block<2, 1>(3, 0) = Tla_to_lr_ *
-                             (::Eigen::Matrix<double, 2, 1>() << velocity,
-                              spline_->DThetaDt(distance, velocity))
-                                 .finished();
+  result.block<2, 1>(3, 0) =
+      Tla_to_lr_ * (::Eigen::Matrix<double, 2, 1>() << velocity,
+                    spline_->DThetaDt(distance, velocity))
+                       .finished();
   return result;
 }
 
 ::Eigen::Matrix<double, 3, 1> Trajectory::GetNextXVA(
     ::std::chrono::nanoseconds dt, ::Eigen::Matrix<double, 2, 1> *state) {
-  double dt_float =
-      ::std::chrono::duration_cast<::std::chrono::duration<double>>(dt).count();
+  double dt_float = ::aos::time::DurationInSeconds(dt);
 
   // TODO(austin): This feels like something that should be pulled out into
   // a library for re-use.
-  *state = RungeKutta([this](const ::Eigen::Matrix<double, 2, 1> x) {
-    ::Eigen::Matrix<double, 3, 1> xva = FFAcceleration(x(0));
-    return (::Eigen::Matrix<double, 2, 1>() << x(1), xva(2)).finished();
-  }, *state, dt_float);
+  *state = RungeKutta(
+      [this](const ::Eigen::Matrix<double, 2, 1> x) {
+        ::Eigen::Matrix<double, 3, 1> xva = FFAcceleration(x(0));
+        return (::Eigen::Matrix<double, 2, 1>() << x(1), xva(2)).finished();
+      },
+      *state, dt_float);
 
   ::Eigen::Matrix<double, 3, 1> result = FFAcceleration((*state)(0));
   (*state)(1) = result(1);
diff --git a/frc971/control_loops/drivetrain/trajectory_plot.cc b/frc971/control_loops/drivetrain/trajectory_plot.cc
index 8508099..d2dd2c8 100644
--- a/frc971/control_loops/drivetrain/trajectory_plot.cc
+++ b/frc971/control_loops/drivetrain/trajectory_plot.cc
@@ -15,7 +15,8 @@
 //   Basic ideas from spline following are from Jared Russell and
 //   http://msc.fe.uni-lj.si/Papers/Chapter10_MobileRobotsNewResearch_Lepetic2005.pdf
 //
-// For the future, I'd like to use the following to measure distance to the path.
+// For the future, I'd like to use the following to measure distance to the
+// path.
 //   http://home.eps.hw.ac.uk/~ab226/papers/dist.pdf
 //
 // LQR controller was inspired by
@@ -109,9 +110,7 @@
   ::std::vector<double> length_plan_vl;
   ::std::vector<double> length_plan_vr;
   const chrono::nanoseconds kDt = chrono::microseconds(5050);
-  const double kDtDouble =
-      ::std::chrono::duration_cast<::std::chrono::duration<double>>(kDt)
-          .count();
+  const double kDtDouble = ::aos::time::DurationInSeconds(kDt);
   {
     ::std::vector<::Eigen::Matrix<double, 3, 1>> length_plan_xva =
         trajectory.PlanXVA(kDt);