fixes formatting

Author: jctoledo

drivers/neo6m/src/lib.rs

@@ -1,7 +1,8 @@
 //! NEO-6M GPS NMEA Parser
 //!
-//! This crate provides a pure Rust parser for NMEA sentences from NEO-6M GPS receivers.
-//! It supports GPRMC and GNRMC sentences and provides position, velocity, and time information.
+//! This crate provides a pure Rust parser for NMEA sentences from NEO-6M GPS
+//! receivers. It supports GPRMC and GNRMC sentences and provides position,
+//! velocity, and time information.
 //!
 //! # Features
 //!
@@ -25,7 +26,11 @@
 //!     if parser.feed_byte(byte) {
 //!         // New sentence parsed
 //!         if parser.last_fix().valid {
-//!             println!("Position: {}, {}", parser.last_fix().lat, parser.last_fix().lon);
+//!             println!(
+//!                 "Position: {}, {}",
+//!                 parser.last_fix().lat,
+//!                 parser.last_fix().lon
+//!             );
 //!             println!("Speed: {:.1} m/s", parser.last_fix().speed);
 //!         }
 //!     }
@@ -34,12 +39,11 @@
 
 #![cfg_attr(not(test), no_std)]
 
+// Import libm for no-std floating point operations
+use libm::{cos, floor, sin};
 #[cfg(feature = "logging")]
 use log::warn;
 
-// Import libm for no-std floating point operations
-use libm::{cos, sin, floor};
-
 /// GPS coordinate transformations
 pub mod transforms {
     use libm::{cos, sqrtf};
@@ -258,7 +262,8 @@ impl NmeaParser {
     /// Update position-based speed with new timestamp
     ///
     /// Call this from your application's time source when a new fix arrives.
-    /// This allows position-based speed calculation to work in no_std environments.
+    /// This allows position-based speed calculation to work in no_std
+    /// environments.
     ///
     /// # Arguments
     ///
@@ -372,8 +377,8 @@ impl NmeaParser {
     #[cfg(not(any(test, feature = "std")))]
     fn parse_rmc(&mut self, _line: &str) {
         // no_std: Simplified implementation
-        // For a full no_std implementation, you would need to add libm dependency for floor()
-        // and implement manual field parsing without Vec
+        // For a full no_std implementation, you would need to add libm dependency for
+        // floor() and implement manual field parsing without Vec
         self.last_fix.valid = false;
     }
 }
@@ -426,7 +431,10 @@ mod tests {
         // North latitude
         assert_eq!(parse_coordinate("3723.2475", "N"), Some(37.387458333333336));
         // South latitude
-        assert_eq!(parse_coordinate("3723.2475", "S"), Some(-37.387458333333336));
+        assert_eq!(
+            parse_coordinate("3723.2475", "S"),
+            Some(-37.387458333333336)
+        );
         // East longitude
         assert_eq!(parse_coordinate("12158.3416", "E"), Some(121.97236));
         // West longitude

drivers/wt901/src/lib.rs

@@ -14,7 +14,7 @@
 //! # Example
 //!
 //! ```no_run
-//! use wt901::{Wt901Parser, PacketType};
+//! use wt901::{PacketType, Wt901Parser};
 //!
 //! let mut parser = Wt901Parser::new();
 //!
@@ -181,8 +181,10 @@ impl Wt901Parser {
 
         if checksum != self.buffer[10] {
             #[cfg(feature = "logging")]
-            warn!("WT901 checksum failed: expected 0x{:02X}, got 0x{:02X}",
-                  self.buffer[10], checksum);
+            warn!(
+                "WT901 checksum failed: expected 0x{:02X}, got 0x{:02X}",
+                self.buffer[10], checksum
+            );
             return None;
         }
 

framework/src/ekf.rs

@@ -1,6 +1,5 @@
 /// Extended Kalman Filter for vehicle state estimation
 /// 7-state: [x, y, ψ, vx, vy, bax, bay]
-
 use core::f32::consts::PI;
 
 const N: usize = 7; // State dimension
@@ -10,17 +9,17 @@ const N: usize = 7; // State dimension
 #[derive(Debug, Clone, Copy)]
 pub struct EkfConfig {
     // Process noise parameters
-    pub q_acc: f32,    // (m/s²)² - Acceleration process noise
-    pub q_gyro: f32,   // (rad/s)² - Gyro process noise
-    pub q_bias: f32,   // (m/s²)² - Bias evolution noise
+    pub q_acc: f32,  // (m/s²)² - Acceleration process noise
+    pub q_gyro: f32, // (rad/s)² - Gyro process noise
+    pub q_bias: f32, // (m/s²)² - Bias evolution noise
 
     // Measurement noise parameters
-    pub r_pos: f32,    // (m)² - GPS position measurement noise
-    pub r_vel: f32,    // (m/s)² - GPS velocity measurement noise
-    pub r_yaw: f32,    // (rad)² - Magnetometer yaw measurement noise
+    pub r_pos: f32, // (m)² - GPS position measurement noise
+    pub r_vel: f32, // (m/s)² - GPS velocity measurement noise
+    pub r_yaw: f32, // (rad)² - Magnetometer yaw measurement noise
 
     // Model parameters
-    pub min_speed: f32,  // m/s - Minimum speed for CTRA model
+    pub min_speed: f32, // m/s - Minimum speed for CTRA model
 }
 
 impl Default for EkfConfig {
@@ -61,38 +60,38 @@ impl Ekf {
             config,
         }
     }
-    
+
     /// Get position (x, y)
     pub fn position(&self) -> (f32, f32) {
         (self.x[0], self.x[1])
     }
-    
+
     /// Get yaw (ψ)
     pub fn yaw(&self) -> f32 {
         self.x[2]
     }
-    
+
     /// Get velocity (vx, vy)
     pub fn velocity(&self) -> (f32, f32) {
         (self.x[3], self.x[4])
     }
-    
+
     /// Get speed (magnitude of velocity)
     pub fn speed(&self) -> f32 {
         (self.x[3] * self.x[3] + self.x[4] * self.x[4]).sqrt()
     }
-    
+
     /// Get accelerometer biases (bax, bay)
     #[allow(dead_code)]
     pub fn biases(&self) -> (f32, f32) {
         (self.x[5], self.x[6])
     }
-    
+
     /// Prediction step using CTRA or constant acceleration model
     pub fn predict(&mut self, ax_earth: f32, ay_earth: f32, wz: f32, dt: f32) {
         let speed = self.speed();
         let use_ctra = speed > self.config.min_speed;
-        
+
         // Copy values to avoid borrowing issues
         let mut x = self.x[0];
         let mut y = self.x[1];
@@ -101,7 +100,7 @@ impl Ekf {
         let mut vy = self.x[4];
         let bax = self.x[5];
         let bay = self.x[6];
-        
+
         // Predict position
         if use_ctra && wz.abs() > 1e-4 {
             // CTRA model (Constant Turn Rate and Acceleration)
@@ -114,23 +113,23 @@ impl Ekf {
             x += vx * dt + 0.5 * (ax_earth - bax) * dt * dt;
             y += vy * dt + 0.5 * (ay_earth - bay) * dt * dt;
         }
-        
+
         // Predict yaw
         psi += wz * dt;
         psi = wrap_angle(psi);
-        
+
         // Predict velocity
         vx += (ax_earth - bax) * dt;
         vy += (ay_earth - bay) * dt;
-        
+
         // Write back to state
         self.x[0] = x;
         self.x[1] = y;
         self.x[2] = psi;
         self.x[3] = vx;
         self.x[4] = vy;
         // Biases remain constant (self.x[5] and self.x[6] unchanged)
-        
+
         // Update covariance (diagonal approximation)
         let qx = 0.25 * self.config.q_acc * dt * dt;
         let qv = self.config.q_acc * dt * dt;
@@ -142,7 +141,7 @@ impl Ekf {
         self.p[5] += self.config.q_bias * dt + 1e-6;
         self.p[6] += self.config.q_bias * dt + 1e-6;
     }
-    
+
     /// Update with GPS position measurement
     pub fn update_position(&mut self, z_x: f32, z_y: f32) {
         // X position update
@@ -172,34 +171,34 @@ impl Ekf {
         self.x[4] += k_y * (z_vy - self.x[4]);
         self.p[4] *= 1.0 - k_y;
     }
-    
+
     /// Update with scalar speed measurement
     pub fn update_speed(&mut self, z_speed: f32) {
         let r_spd = if z_speed < 0.3 { 0.20 } else { 0.04 }; // Adaptive R
-        
+
         let v_est = self.speed().max(0.05); // Avoid division by zero
-        
+
         // Jacobian H = [vx/v, vy/v]
         let h_x = self.x[3] / v_est;
         let h_y = self.x[4] / v_est;
-        
+
         // Innovation covariance
         let s = h_x * h_x * self.p[3] + h_y * h_y * self.p[4] + r_spd;
-        
+
         // Kalman gains
         let k_x = self.p[3] * h_x / s;
         let k_y = self.p[4] * h_y / s;
-        
+
         // Innovation
         let y = z_speed - v_est;
-        
+
         // Update
         self.x[3] += k_x * y;
         self.x[4] += k_y * y;
         self.p[3] -= k_x * h_x * self.p[3];
         self.p[4] -= k_y * h_y * self.p[4];
     }
-    
+
     /// Update with IMU yaw measurement (from magnetometer)
     pub fn update_yaw(&mut self, z_yaw: f32) {
         // Wrap innovation to [-π, π]
@@ -212,24 +211,24 @@ impl Ekf {
         self.x[2] = wrap_angle(self.x[2]);
         self.p[2] *= 1.0 - k;
     }
-    
+
     /// Update accelerometer biases when stationary
     pub fn update_bias(&mut self, z_ax: f32, z_ay: f32) {
         const R_BIAS: f32 = 0.05 * 0.05; // (0.05 m/s²)²
-        
+
         // BAX update
         let s_x = self.p[5] + R_BIAS;
         let k_x = self.p[5] / s_x;
         self.x[5] += k_x * (z_ax - self.x[5]);
         self.p[5] *= 1.0 - k_x;
-        
+
         // BAY update
         let s_y = self.p[6] + R_BIAS;
         let k_y = self.p[6] / s_y;
         self.x[6] += k_y * (z_ay - self.x[6]);
         self.p[6] *= 1.0 - k_y;
     }
-    
+
     /// Zero-velocity update (ZUPT) - force velocity to zero
     pub fn zupt(&mut self) {
         self.update_velocity(0.0, 0.0);
@@ -252,14 +251,14 @@ fn wrap_angle(angle: f32) -> f32 {
 #[cfg(test)]
 mod tests {
     use super::*;
-    
+
     #[test]
     fn test_ekf_init() {
         let ekf = Ekf::new();
         assert_eq!(ekf.position(), (0.0, 0.0));
         assert_eq!(ekf.speed(), 0.0);
     }
-    
+
     #[test]
     fn test_wrap_angle() {
         assert!((wrap_angle(0.0) - 0.0).abs() < 0.001);