fix: Ensure single-precision float operations in ads7138, as5600, bldc_haptics, bldc_motor, encoder, filters, mt6701, and tla2528 components (#531)

* fix: Ensure single-precision float operations in `ads7138`, `as5600`, `bldc_haptics`, `bldc_motor`, `encoder`, `filters`, `mt6701`, and `tla2528` components

* ensure float versions of functions are used

Author: finger563

components/ads7138/include/ads7138.hpp

@@ -1240,7 +1240,7 @@ class Ads7138 : public BasePeripheral<> {
     // can represent avdd_mv_ volts with 65536 values
     // therefore, each value represents avdd_mv_ / 65536 volts.
     // multiply by 1000 to get mV
-    return static_cast<float>(raw) * avdd_mv_ / 65536.0;
+    return static_cast<float>(raw) * avdd_mv_ / 65536.0f;
   }
 
   /**

components/as5600/include/as5600.hpp

@@ -44,7 +44,7 @@ class As5600 : public BasePeripheral<> {
   static constexpr float COUNTS_PER_REVOLUTION_F =
       16384.0f; ///< Float number of counts per revolution for the magnetic encoder.
   static constexpr float COUNTS_TO_RADIANS =
-      2.0f * M_PI /
+      2.0f * (float)(M_PI) /
       COUNTS_PER_REVOLUTION_F; ///< Conversion factor to convert from count value to radians.
   static constexpr float COUNTS_TO_DEGREES =
       360.0f /

components/bldc_haptics/include/bldc_haptics.hpp

@@ -223,8 +223,8 @@ template <MotorConcept M> class BldcHaptics : public BaseComponent {
     // small for the P factor to work well.
     const float derivative_lower_strength = config.detent_strength * kd_factor_max_;
     const float derivative_upper_strength = config.detent_strength * kd_factor_min_;
-    const float derivative_position_width_lower = 3.0f * M_PI / 180.0f; // radians(3);
-    const float derivative_position_width_upper = 8.0f * M_PI / 180.0f; // radians(8);
+    const float derivative_position_width_lower = 3.0f * (float)(M_PI) / 180.0f; // radians(3);
+    const float derivative_position_width_upper = 8.0f * (float)(M_PI) / 180.0f; // radians(8);
     const float raw = derivative_lower_strength +
                       (derivative_upper_strength - derivative_lower_strength) /
                           (derivative_position_width_upper - derivative_position_width_lower) *

components/bldc_haptics/include/detent_config.hpp

@@ -18,11 +18,13 @@ struct DetentConfig {
                                        ///< detents will be used.
   float detent_strength{1};            ///< Strength of the detents
   float end_strength{1};               ///< Strength of the end detents
-  float snap_point{1.1}; ///< Position of the snap point, in radians, should be >= 0.5 for stability
+  float snap_point{
+      1.1f}; ///< Position of the snap point, in radians, should be >= 0.5 for stability
   float snap_point_bias{0}; ///< Bias for the snap point, in radians, should be >= 0 for stability
   float dead_zone_percent{0.2f}; ///< Percent of the dead zone to use for the detent
   float dead_zone_abs_max_radians{
-      M_PI / 180.0f}; ///< Absolute maximum of the dead zone to use for the detent in radians
+      (float)(M_PI) /
+      180.0f}; ///< Absolute maximum of the dead zone to use for the detent in radians
 };
 
 /// @brief Equality operator for DetentConfig
@@ -41,107 +43,107 @@ inline bool operator==(const DetentConfig &lhs, const DetentConfig &rhs) {
 
 /// @brief Unbounded motion, no detents
 static const DetentConfig UNBOUNDED_NO_DETENTS = {
-    .position_width = 10.0 * M_PI / 180.0,
+    .position_width = 10.0f * (float)(M_PI) / 180.0f,
     .min_position = 0,
     .max_position = -1, // max < min indicates no bounds
     .detent_strength = 0,
     .end_strength = 1,
-    .snap_point = 1.1,
+    .snap_point = 1.1f,
     .snap_point_bias = 0,
 };
 
 /// @brief Bounded motion, no detents
 static const DetentConfig BOUNDED_NO_DETENTS = {
-    .position_width = 10.0 * M_PI / 180.0,
+    .position_width = 10.0f * (float)(M_PI) / 180.0f,
     .min_position = 0,
     .max_position = 10,
     .detent_strength = 0,
     .end_strength = 1,
-    .snap_point = 1.1,
+    .snap_point = 1.1f,
     .snap_point_bias = 0,
 };
 
 /// @brief Bounded motion with multiple revolutions, no detents, with end stops
 static const DetentConfig MULTI_REV_NO_DETENTS = {
-    .position_width = 10.0 * M_PI / 180.0,
+    .position_width = 10.0f * (float)(M_PI) / 180.0f,
     .min_position = 0,
     .max_position = 72,
     .detent_strength = 0,
     .end_strength = 1,
-    .snap_point = 1.1,
+    .snap_point = 1.1f,
     .snap_point_bias = 0,
 };
 
 /// @brief On-off with strong detents
 static const DetentConfig ON_OFF_STRONG_DETENTS = {
-    .position_width = 60.0 * M_PI / 180.0,
+    .position_width = 60.0f * (float)(M_PI) / 180.0f,
     .min_position = 0,
     .max_position = 1,
     .detent_strength = 1,
     .end_strength = 1,
-    .snap_point = 0.55, // Note the snap point is slightly past the midpoint (0.5); compare to
-                        // normal detents which use a snap point *past* the next value (i.e. > 1)
+    .snap_point = 0.55f, // Note the snap point is slightly past the midpoint (0.5); compare to
+                         // normal detents which use a snap point *past* the next value (i.e. > 1)
     .snap_point_bias = 0,
 };
 
 /// @brief Bounded motion with strong position detents spaced 9 degrees apart
 /// (coarse), with end stops
 static const DetentConfig COARSE_VALUES_STRONG_DETENTS = {
-    .position_width = 8.225f * M_PI / 180.0,
+    .position_width = 8.225f * (float)(M_PI) / 180.0f,
     .min_position = 0,
     .max_position = 31,
     .detent_strength = 2,
     .end_strength = 1,
-    .snap_point = 1.1,
+    .snap_point = 1.1f,
     .snap_point_bias = 0,
 };
 
 /// @brief Bounded motion with no detents spaced 1 degree apart (fine), with end
 /// stops
 static const DetentConfig FINE_VALUES_NO_DETENTS = {
-    .position_width = 1.0f * M_PI / 180.0,
+    .position_width = 1.0f * (float)(M_PI) / 180.0f,
     .min_position = 0,
     .max_position = 255,
     .detent_strength = 0,
     .end_strength = 1,
-    .snap_point = 1.1,
+    .snap_point = 1.1f,
     .snap_point_bias = 0,
 };
 
 /// @brief Bounded motion with position detents spaced 1 degree apart (fine),
 /// with end stops
 static const DetentConfig FINE_VALUES_WITH_DETENTS = {
-    .position_width = 1.0f * M_PI / 180.0,
+    .position_width = 1.0f * (float)(M_PI) / 180.0f,
     .min_position = 0,
     .max_position = 255,
     .detent_strength = 1,
     .end_strength = 1,
-    .snap_point = 1.1,
+    .snap_point = 1.1f,
     .snap_point_bias = 0,
 };
 
 /// @brief Bounded motion with position detents, end stops, and explicit
 /// magnetic detents.
 static const DetentConfig MAGNETIC_DETENTS = {
-    .position_width = 7.0 * M_PI / 180.0,
+    .position_width = 7.0f * (float)(M_PI) / 180.0f,
     .min_position = 0,
     .max_position = 31,
     .detent_positions = {2, 10, 21, 22},
-    .detent_strength = 2.5,
+    .detent_strength = 2.5f,
     .end_strength = 1,
-    .snap_point = 0.7,
+    .snap_point = 0.7f,
     .snap_point_bias = 0,
 };
 
 /// @brief Bounded motion for a return to center rotary encoder with positions
 static const DetentConfig RETURN_TO_CENTER_WITH_DETENTS = {
-    .position_width = 60.0 * M_PI / 180.0,
+    .position_width = 60.0f * (float)(M_PI) / 180.0f,
     .min_position = -6,
     .max_position = 6,
     .detent_strength = 1,
     .end_strength = 1,
-    .snap_point = 0.55,
-    .snap_point_bias = 0.4,
+    .snap_point = 0.55f,
+    .snap_point_bias = 0.4f,
 };
 
 } // namespace espp::detail
@@ -155,23 +157,23 @@ template <> struct fmt::formatter<espp::detail::DetentConfig> {
 
   template <typename FormatContext>
   auto format(espp::detail::DetentConfig const &detent_config, FormatContext &ctx) const {
-    return fmt::format_to(ctx.out(),
-                          "DetentConfig:\n"
-                          "\tposition_width: {} radians ({} degrees)\n"
-                          "\tmin_position: {}\n"
-                          "\tmax_position: {}\n"
-                          "\trange of motion: {:.2f} to {:.2f} degrees\n"
-                          "\tdetent_positions: {}\n"
-                          "\tdetent_strength: {}\n"
-                          "\tend_strength: {}\n"
-                          "\tsnap_point: {}\n"
-                          "\tsnap_point_bias: {}",
-                          detent_config.position_width, detent_config.position_width * 180.0 / M_PI,
-                          detent_config.min_position, detent_config.max_position,
-                          detent_config.min_position * detent_config.position_width * 180.0 / M_PI,
-                          detent_config.max_position * detent_config.position_width * 180.0 / M_PI,
-                          detent_config.detent_positions, detent_config.detent_strength,
-                          detent_config.end_strength, detent_config.snap_point,
-                          detent_config.snap_point_bias);
+    return fmt::format_to(
+        ctx.out(),
+        "DetentConfig:\n"
+        "\tposition_width: {} radians ({} degrees)\n"
+        "\tmin_position: {}\n"
+        "\tmax_position: {}\n"
+        "\trange of motion: {:.2f} to {:.2f} degrees\n"
+        "\tdetent_positions: {}\n"
+        "\tdetent_strength: {}\n"
+        "\tend_strength: {}\n"
+        "\tsnap_point: {}\n"
+        "\tsnap_point_bias: {}",
+        detent_config.position_width, detent_config.position_width * 180.0f / (float)(M_PI),
+        detent_config.min_position, detent_config.max_position,
+        detent_config.min_position * detent_config.position_width * 180.0f / (float)(M_PI),
+        detent_config.max_position * detent_config.position_width * 180.0f / (float)(M_PI),
+        detent_config.detent_positions, detent_config.detent_strength, detent_config.end_strength,
+        detent_config.snap_point, detent_config.snap_point_bias);
   }
 };

components/bldc_motor/include/bldc_motor.hpp

@@ -412,15 +412,15 @@ class BldcMotor : public BaseComponent {
         Uout = 1.0f / (fast_inv_sqrt(ud * ud + uq * uq) * driver_->get_voltage_limit());
         // angle normalisation in between 0 and 2pi
         // only necessary if using fast_sin and fast_cos - approximation functions
-        el_angle = normalize_angle(el_angle + atan2(uq, ud));
+        el_angle = normalize_angle(el_angle + atan2f(uq, ud));
       } else { // only uq available - no need for atan2 and sqrt
         Uout = uq / driver_->get_voltage_limit();
         // angle normalisation in between 0 and 2pi
         // only necessary if using fast_sin and fast_cos - approximation functions
-        el_angle = normalize_angle(el_angle + M_PI_2);
+        el_angle = normalize_angle(el_angle + (float)(M_PI_2));
       }
       // find the sector we are in currently
-      sector = floor(el_angle / _PI_3) + 1;
+      sector = floorf(el_angle / _PI_3) + 1;
       // calculate the duty cycles
       float T1 = _SQRT3 * fast_sin(sector * _PI_3 - el_angle) * Uout;
       float T2 = _SQRT3 * fast_sin(el_angle - (sector - 1.0f) * _PI_3) * Uout;

components/bldc_motor/include/foc_utils.hpp

@@ -6,12 +6,12 @@ namespace espp {
 /**
  * @brief Conversion factor to go from rotations/minute to radians/second.
  */
-static constexpr float RPM_TO_RADS = (2.0f * M_PI) / 60.0f;
+static constexpr float RPM_TO_RADS = (2.0f * (float)(M_PI)) / 60.0f;
 
 /**
  * @brief Conversion factor to go from radians/second to rotations/minute.
  */
-static constexpr float RADS_TO_RPM = 60.0f / (2.0f * M_PI);
+static constexpr float RADS_TO_RPM = 60.0f / (2.0f * (float)(M_PI));
 
 static constexpr float _2_SQRT3 = 1.15470053838f;
 static constexpr float _SQRT3 = 1.73205080757f;

components/bmi270/include/bmi270.hpp

@@ -327,9 +327,9 @@ class Bmi270 : public espp::BasePeripheral<uint8_t, Interface == bmi270::Interfa
       orientation_ = orientation_filter_(dt, accel, gyro);
       // Calculate gravity vector from orientation
       gravity_vector_ = {
-          static_cast<float>(sin(orientation_.pitch)),
-          static_cast<float>(-sin(orientation_.roll) * cos(orientation_.pitch)),
-          static_cast<float>(-cos(orientation_.roll) * cos(orientation_.pitch)),
+          static_cast<float>(sinf(orientation_.pitch)),
+          static_cast<float>(-sinf(orientation_.roll) * cosf(orientation_.pitch)),
+          static_cast<float>(-cosf(orientation_.roll) * cosf(orientation_.pitch)),
       };
     }
 

components/encoder/include/abi_encoder.hpp

@@ -119,7 +119,7 @@ template <EncoderType T = EncoderType::ROTATIONAL> class AbiEncoder : public Bas
    * @return Number of radians, as a floating point number.
    */
   float get_radians() requires(T == EncoderType::ROTATIONAL) {
-    return get_revolutions() * 2.0f * M_PI;
+    return get_revolutions() * 2.0f * (float)(M_PI);
   }
 
   /**

components/file_system/src/file_system.cpp

@@ -81,7 +81,7 @@ std::string FileSystem::human_readable(size_t bytes) {
   float mantissa = bytes;
   for (; mantissa >= 1024.0f; mantissa /= 1024.0f, ++i) {
   }
-  mantissa = std::ceilf(mantissa * 10.0f) / 10.0f;
+  mantissa = ceilf(mantissa * 10.0f) / 10.0f;
   return i == 0 ? fmt::format("{}", bytes) : fmt::format("{:.3f}{}", mantissa, "BKMGTPE"[i]);
 }
 

components/filters/example/main/filters_example.cpp

@@ -48,7 +48,7 @@ extern "C" void app_main(void) {
       float seconds = std::chrono::duration<float>(now - start).count();
       // use time to create a stairstep function
       constexpr float noise_scale = 0.2f;
-      float input = floor(seconds) + get_random() * noise_scale;
+      float input = floorf(seconds) + get_random() * noise_scale;
       fmt::print("{:.03f}, {:.03f}, {:.03f}, {:.03f}, "
                  "{:.03f}, {:.03f}, {:.03f}, {:.03f}\n",
                  seconds, input, slpf.update(input), lpf.update(input), bwf_df1_o1.update(input),