diff --git a/Firmware/MotorControl/axis.cpp b/Firmware/MotorControl/axis.cpp
index 51a66c18..fbef6135 100644
--- a/Firmware/MotorControl/axis.cpp
+++ b/Firmware/MotorControl/axis.cpp
@@ -241,9 +241,9 @@ bool Axis::run_lockin_spin(const LockinConfig_t& lockin_config) {
     auto spin_done = [&](bool vel_override = false) -> bool {
         bool done = false;
         if (lockin_config.finish_on_vel || vel_override)
-            done = done || fabsf(vel) >= fabsf(lockin_config.vel);
+            done = done || std::abs(vel) >= std::abs(lockin_config.vel);
         if (lockin_config.finish_on_distance)
-            done = done || fabsf(distance) >= fabsf(lockin_config.finish_distance);
+            done = done || std::abs(distance) >= std::abs(lockin_config.finish_distance);
         if (lockin_config.finish_on_enc_idx)
             done = done || encoder_.index_found_;
         return done;
diff --git a/Firmware/MotorControl/controller.cpp b/Firmware/MotorControl/controller.cpp
index db7d3642..088b6d15 100644
--- a/Firmware/MotorControl/controller.cpp
+++ b/Firmware/MotorControl/controller.cpp
@@ -88,8 +88,8 @@ bool Controller::home_axis() {
 bool Controller::anticogging_calibration(float pos_estimate, float vel_estimate) {
     if (config_.anticogging.calib_anticogging) {
         float pos_err = input_pos_ - pos_estimate;
-        if (fabsf(pos_err) <= config_.anticogging.calib_pos_threshold &&
-            fabsf(vel_estimate) < config_.anticogging.calib_vel_threshold) {
+        if (std::abs(pos_err) <= config_.anticogging.calib_pos_threshold &&
+            std::abs(vel_estimate) < config_.anticogging.calib_vel_threshold) {
             config_.anticogging.cogging_map[std::clamp<uint32_t>(config_.anticogging.index++, 0, 3600)] = vel_integrator_current_;
         }
         if (config_.anticogging.index < 3600) {
@@ -214,7 +214,7 @@ bool Controller::update(float pos_estimate, float vel_estimate, float* current_s
         }
         vel_des += config_.pos_gain * pos_err;
         // V-shaped gain shedule based on position error
-        float abs_pos_err = fabsf(pos_err);
+        float abs_pos_err = std::abs(pos_err);
         if (config_.enable_gain_scheduling && abs_pos_err <= config_.gain_scheduling_width) {
             gain_scheduling_multiplier = abs_pos_err / config_.gain_scheduling_width;
         }
diff --git a/Firmware/MotorControl/encoder.cpp b/Firmware/MotorControl/encoder.cpp
index fc2eac2a..c91361fd 100644
--- a/Firmware/MotorControl/encoder.cpp
+++ b/Firmware/MotorControl/encoder.cpp
@@ -97,7 +97,7 @@ void Encoder::set_linear_count(int32_t count) {
 
     // Update states
     shadow_count_   = count;
-    pos_estimate_   = (float)count;
+    pos_estimate_   = static_cast<float>(count);
     tim_cnt_sample_ = count;
 
     //Write hardware last
@@ -119,7 +119,7 @@ void Encoder::set_circular_count(int32_t count, bool update_offset) {
 
     // Update states
     count_in_cpr_ = mod(count, config_.cpr);
-    pos_cpr_      = (float)count_in_cpr_;
+    pos_cpr_      = static_cast<float>(count_in_cpr_);
 
     cpu_exit_critical(prim);
 }
@@ -166,7 +166,7 @@ bool Encoder::run_direction_find() {
 // TODO: Do the scan with current, not voltage!
 bool Encoder::run_offset_calibration() {
     static const float start_lock_duration = 1.0f;
-    static const int num_steps             = (int)(config_.calib_scan_distance / config_.calib_scan_omega * (float)current_meas_hz);
+    static const int num_steps             = (int)(config_.calib_scan_distance / config_.calib_scan_omega * static_cast<float>(current_meas_hz));
 
     // Require index found if enabled
     if (config_.use_index && !index_found_) {
@@ -203,7 +203,7 @@ bool Encoder::run_offset_calibration() {
     // scan forward
     i = 0;
     axis_->run_control_loop([&]() {
-        float phase   = wrap_pm_pi(config_.calib_scan_distance * (float)i / (float)num_steps - config_.calib_scan_distance / 2.0f);
+        float phase   = wrap_pm_pi(config_.calib_scan_distance * static_cast<float>(i) / static_cast<float>(num_steps) - config_.calib_scan_distance / 2.0f);
         float v_alpha = voltage_magnitude * our_arm_cos_f32(phase);
         float v_beta  = voltage_magnitude * our_arm_sin_f32(phase);
         if (!axis_->motor_.enqueue_voltage_timings(v_alpha, v_beta))
@@ -232,10 +232,10 @@ bool Encoder::run_offset_calibration() {
 
     //TODO avoid recomputing elec_rad_per_enc every time
     // Check CPR
-    float elec_rad_per_enc       = axis_->motor_.config_.pole_pairs * 2 * M_PI * (1.0f / (float)(config_.cpr));
+    float elec_rad_per_enc       = axis_->motor_.config_.pole_pairs * 2 * M_PI * (1.0f / static_cast<float>(config_.cpr));
     float expected_encoder_delta = config_.calib_scan_distance / elec_rad_per_enc;
-    calib_scan_response_         = fabsf(shadow_count_ - init_enc_val);
-    if (fabsf(calib_scan_response_ - expected_encoder_delta) / expected_encoder_delta > config_.calib_range) {
+    calib_scan_response_         = std::abs(shadow_count_ - init_enc_val);
+    if (std::abs(calib_scan_response_ - expected_encoder_delta) / expected_encoder_delta > config_.calib_range) {
         set_error(ERROR_CPR_OUT_OF_RANGE);
         return false;
     }
@@ -243,7 +243,7 @@ bool Encoder::run_offset_calibration() {
     // scan backwards
     i = 0;
     axis_->run_control_loop([&]() {
-        float phase   = wrap_pm_pi(-config_.calib_scan_distance * (float)i / (float)num_steps + config_.calib_scan_distance / 2.0f);
+        float phase   = wrap_pm_pi(-config_.calib_scan_distance * static_cast<float>(i) / static_cast<float>(num_steps) + config_.calib_scan_distance / 2.0f);
         float v_alpha = voltage_magnitude * our_arm_cos_f32(phase);
         float v_beta  = voltage_magnitude * our_arm_sin_f32(phase);
         if (!axis_->motor_.enqueue_voltage_timings(v_alpha, v_beta))
@@ -259,7 +259,7 @@ bool Encoder::run_offset_calibration() {
 
     config_.offset       = encvaluesum / (num_steps * 2);
     int32_t residual     = encvaluesum - ((int64_t)config_.offset * (int64_t)(num_steps * 2));
-    config_.offset_float = (float)residual / (float)(num_steps * 2) + 0.5f;  // add 0.5 to center-align state to phase
+    config_.offset_float = static_cast<float>(residual) / static_cast<float>(num_steps * 2) + 0.5f;  // add 0.5 to center-align state to phase
 
     is_ready_ = true;
     return true;
@@ -490,16 +490,16 @@ bool Encoder::update() {
     pos_estimate_ += current_meas_period * vel_estimate_;
     pos_cpr_ += current_meas_period * vel_estimate_;
     // discrete phase detector
-    float delta_pos     = (float)(shadow_count_ - (int32_t)floorf(pos_estimate_));
-    float delta_pos_cpr = (float)(count_in_cpr_ - (int32_t)floorf(pos_cpr_));
-    delta_pos_cpr       = wrap_pm(delta_pos_cpr, 0.5f * (float)(config_.cpr));
+    float delta_pos     = static_cast<float>(shadow_count_) - static_cast<int32_t>(std::floor(pos_estimate_));
+    float delta_pos_cpr = static_cast<float>(count_in_cpr_) - static_cast<int32_t>(std::floor(pos_cpr_));
+    delta_pos_cpr       = wrap_pm(delta_pos_cpr, 0.5f * static_cast<float>(config_.cpr));
     // pll feedback
     pos_estimate_ += current_meas_period * pll_kp_ * delta_pos;
     pos_cpr_ += current_meas_period * pll_kp_ * delta_pos_cpr;
-    pos_cpr_ = fmodf_pos(pos_cpr_, (float)(config_.cpr));
+    pos_cpr_ = fmodf_pos(pos_cpr_, static_cast<float>(config_.cpr));
     vel_estimate_ += current_meas_period * pll_ki_ * delta_pos_cpr;
     bool snap_to_zero_vel = false;
-    if (fabsf(vel_estimate_) < 0.5f * current_meas_period * pll_ki_) {
+    if (std::abs(vel_estimate_) < 0.5f * current_meas_period * pll_ki_) {
         vel_estimate_    = 0.0f;  //align delta-sigma on zero to prevent jitter
         snap_to_zero_vel = true;
     }
@@ -525,7 +525,7 @@ bool Encoder::update() {
 
     //// compute electrical phase
     //TODO avoid recomputing elec_rad_per_enc every time
-    float elec_rad_per_enc = axis_->motor_.config_.pole_pairs * 2 * M_PI * (1.0f / (float)(config_.cpr));
+    float elec_rad_per_enc = axis_->motor_.config_.pole_pairs * 2 * M_PI * (1.0f / static_cast<float>(config_.cpr));
     float ph               = elec_rad_per_enc * (interpolated_enc - config_.offset_float);
     // ph = fmodf(ph, 2*M_PI);
     phase_ = wrap_pm_pi(ph);
diff --git a/Firmware/MotorControl/motor.cpp b/Firmware/MotorControl/motor.cpp
index 92ba073f..81b0dc40 100644
--- a/Firmware/MotorControl/motor.cpp
+++ b/Firmware/MotorControl/motor.cpp
@@ -334,7 +334,7 @@ bool Motor::FOC_current(float Id_des, float Iq_des, float I_phase, float pwm_pha
     ictrl.Iq_setpoint = Iq_des;
 
     // Check for current sense saturation
-    if (fabsf(current_meas_.phB) > ictrl.overcurrent_trip_level || fabsf(current_meas_.phC) > ictrl.overcurrent_trip_level) {
+    if (std::abs(current_meas_.phB) > ictrl.overcurrent_trip_level || std::abs(current_meas_.phC) > ictrl.overcurrent_trip_level) {
         set_error(ERROR_CURRENT_SENSE_SATURATION);
         return false;
     }
diff --git a/Firmware/Tests/test_runner.cpp b/Firmware/Tests/test_runner.cpp
index 0b116fc6..d5a211f9 100644
--- a/Firmware/Tests/test_runner.cpp
+++ b/Firmware/Tests/test_runner.cpp
@@ -281,7 +281,7 @@ TEST_SUITE("vel_ramp") {
         float max_step_size = 0.000125f * vel_ramp_rate;
         float full_step     = input_vel_ - vel_setpoint_;
         float step;
-        if (fabsf(full_step) > max_step_size) {
+        if (std::abs(full_step) > max_step_size) {
             step = std::copysignf(max_step_size, full_step);
         } else {
             step = full_step;