.forgejo/workflows/clippy-check.yml

@@ -0,0 +1,23 @@
+name: Code quality
+
+on: pull_request
+
+jobs:
+  check:
+    runs-on: nix-flakes
+
+    steps:
+      - name: Set up packages
+        run: |
+          echo "extra-substituters = https://builder.naxdy.org/attic" >> /etc/nix/nix.conf
+          echo "extra-trusted-public-keys = attic:05LdE8Nav5Qd1E+KOJqSwdr+WE1z8AUmSb3oKL7s8dk=" >> /etc/nix/nix.conf
+          nix profile install nixpkgs#nodejs "github:zhaofengli/attic?ref=6eabc3f02fae3683bffab483e614bebfcd476b21"
+          echo "PATH=/nix/var/nix/profiles/per-user/root/profile/bin:$PATH" >> "$GITHUB_ENV"
+      - name: Set up attic binary cache
+        run: |
+          attic login "${{ vars.BINARY_CACHE_NAME }}" "${{ vars.BINARY_CACHE_URL }}" "${{ secrets.BINARY_CACHE_AUTH_KEY }}"
+          attic use "${{ vars.BINARY_CACHE_NAME }}"
+      - uses: actions/checkout@v4
+      - name: Run Clippy
+        run: |
+          nix develop . --command cargo clippy -- -Dwarnings

Cargo.toml

@@ -72,7 +72,9 @@ debug = 2
 debug-assertions = false
 incremental = false
 lto = 'fat'
-opt-level = 1
+# opt level needs to be benchmarked after every major feature
+# due to the changes in binary size and alignment
+opt-level = 2
 overflow-checks = false
 
 # do not optimize proc-macro crates = faster builds from scratch

src/input.rs

@@ -117,11 +117,12 @@ pub fn read_ext_adc<
         spi_ccs.set_high();
     }
 
-    return temp_value;
+    temp_value
 }
 
 /// Gets the average stick state over a 1ms interval in a non-blocking fashion.
 /// Will wait until end_time is reached before continuing after reading the ADCs.
+#[allow(clippy::too_many_arguments)]
 #[link_section = ".time_critical.update_stick_states"]
 async fn update_stick_states(
     current_stick_state: &StickState,
@@ -198,17 +199,18 @@ async fn update_stick_states(
     trace!("Raw Stick Values 001: {:?}", raw_stick_values);
 
     let (x_pos_filt, y_pos_filt) =
-        kalman_state.run_kalman(x_z, y_z, &controller_config.astick_config, &filter_gains);
+        kalman_state.run_kalman(x_z, y_z, &controller_config.astick_config, filter_gains);
 
-    let shaped_astick = match run_waveshaping(
+    let shaped_astick = {
-        x_pos_filt,
+        let (x, y) = run_waveshaping(
-        y_pos_filt,
+            x_pos_filt,
-        controller_config.astick_config.x_waveshaping,
+            y_pos_filt,
-        controller_config.astick_config.y_waveshaping,
+            controller_config.astick_config.x_waveshaping,
-        controlstick_waveshaping_values,
+            controller_config.astick_config.y_waveshaping,
-        &filter_gains,
+            controlstick_waveshaping_values,
-    ) {
+            filter_gains,
-        (x, y) => XyValuePair { x, y },
+        );
+        XyValuePair { x, y }
     };
 
     trace!("Shaped Controlstick: {}", shaped_astick);
@@ -220,15 +222,16 @@ async fn update_stick_states(
     old_stick_pos.x = pos_x;
     old_stick_pos.y = pos_y;
 
-    let shaped_cstick = match run_waveshaping(
+    let shaped_cstick = {
-        pos_cx,
+        let (x, y) = run_waveshaping(
-        pos_cy,
+            pos_cx,
-        controller_config.cstick_config.x_waveshaping,
+            pos_cy,
-        controller_config.cstick_config.y_waveshaping,
+            controller_config.cstick_config.x_waveshaping,
-        cstick_waveshaping_values,
+            controller_config.cstick_config.y_waveshaping,
-        &filter_gains,
+            cstick_waveshaping_values,
-    ) {
+            filter_gains,
-        (x, y) => XyValuePair { x, y },
+        );
+        XyValuePair { x, y }
     };
 
     let old_c_pos = XyValuePair {
@@ -250,41 +253,45 @@ async fn update_stick_states(
 
     trace!("Cstick position: {}, {}", pos_cx, pos_cy);
 
-    let mut remapped = match notch_remap(
+    let mut remapped = {
-        pos_x,
+        let (x, y) = notch_remap(
-        pos_y,
+            pos_x,
-        controlstick_params,
+            pos_y,
-        &controller_config.astick_config,
+            controlstick_params,
-        is_calibrating,
+            &controller_config.astick_config,
-    ) {
+            is_calibrating,
-        (x, y) => XyValuePair { x, y },
+        );
+        XyValuePair { x, y }
     };
-    let mut remapped_c = match notch_remap(
+    let mut remapped_c = {
-        pos_cx_filt,
+        let (x, y) = notch_remap(
-        pos_cy_filt,
+            pos_cx_filt,
-        cstick_params,
+            pos_cy_filt,
-        &controller_config.cstick_config,
+            cstick_params,
-        is_calibrating,
+            &controller_config.cstick_config,
-    ) {
+            is_calibrating,
-        (x, y) => XyValuePair { x, y },
+        );
+        XyValuePair { x, y }
     };
-    let remapped_unfiltered = match notch_remap(
+    let remapped_unfiltered = {
-        raw_stick_values.a_linearized.x,
+        let (x, y) = notch_remap(
-        raw_stick_values.a_linearized.y,
+            raw_stick_values.a_linearized.x,
-        controlstick_params,
+            raw_stick_values.a_linearized.y,
-        &controller_config.astick_config,
+            controlstick_params,
-        is_calibrating,
+            &controller_config.astick_config,
-    ) {
+            is_calibrating,
-        (x, y) => XyValuePair { x, y },
+        );
+        XyValuePair { x, y }
     };
-    let remapped_c_unfiltered = match notch_remap(
+    let remapped_c_unfiltered = {
-        raw_stick_values.c_linearized.x,
+        let (x, y) = notch_remap(
-        raw_stick_values.c_linearized.y,
+            raw_stick_values.c_linearized.x,
-        cstick_params,
+            raw_stick_values.c_linearized.y,
-        &controller_config.cstick_config,
+            cstick_params,
-        is_calibrating,
+            &controller_config.cstick_config,
-    ) {
+            is_calibrating,
-        (x, y) => XyValuePair { x, y },
+        );
+        XyValuePair { x, y }
     };
 
     trace!(
@@ -309,20 +316,20 @@ async fn update_stick_states(
     let mut out_stick_state = current_stick_state.clone();
 
     let diff_x = (remapped.x + FLOAT_ORIGIN) - current_stick_state.ax as f32;
-    if (diff_x > (1.0 + STICK_HYST_VAL)) || (diff_x < -STICK_HYST_VAL) {
+    if !(-STICK_HYST_VAL..=(1.0 + STICK_HYST_VAL)).contains(&diff_x) {
         out_stick_state.ax = (remapped.x + FLOAT_ORIGIN) as u8;
     }
     let diff_y = (remapped.y + FLOAT_ORIGIN) - current_stick_state.ay as f32;
-    if (diff_y > (1.0 + STICK_HYST_VAL)) || (diff_y < -STICK_HYST_VAL) {
+    if !(-STICK_HYST_VAL..=(1.0 + STICK_HYST_VAL)).contains(&diff_y) {
         out_stick_state.ay = (remapped.y + FLOAT_ORIGIN) as u8;
     }
 
     let diff_cx = (remapped_c.x + FLOAT_ORIGIN) - current_stick_state.cx as f32;
-    if (diff_cx > (1.0 + STICK_HYST_VAL)) || (diff_cx < -STICK_HYST_VAL) {
+    if !(-STICK_HYST_VAL..=(1.0 + STICK_HYST_VAL)).contains(&diff_cx) {
         out_stick_state.cx = (remapped_c.x + FLOAT_ORIGIN) as u8;
     }
     let diff_cy = (remapped_c.y + FLOAT_ORIGIN) - current_stick_state.cy as f32;
-    if (diff_cy > (1.0 + STICK_HYST_VAL)) || (diff_cy < -STICK_HYST_VAL) {
+    if !(-STICK_HYST_VAL..=(1.0 + STICK_HYST_VAL)).contains(&diff_cy) {
         out_stick_state.cy = (remapped_c.y + FLOAT_ORIGIN) as u8;
     }
 
@@ -337,6 +344,7 @@ async fn update_stick_states(
     out_stick_state
 }
 
+#[allow(clippy::too_many_arguments)]
 fn update_button_states<
     A: Pin,
     B: Pin,
@@ -405,6 +413,7 @@ pub async fn input_integrity_benchmark() {
 
 /// Task responsible for updating the button states.
 /// Publishes the result to CHANNEL_GCC_STATE.
+#[allow(clippy::too_many_arguments)]
 #[embassy_executor::task]
 pub async fn update_button_state_task(
     btn_z: Input<'static, AnyPin>,
@@ -424,6 +433,8 @@ pub async fn update_button_state_task(
     if btn_a.is_low() && btn_x.is_low() && btn_y.is_low() {
         info!("Detected reset button press, booting into flash.");
         embassy_rp::rom_data::reset_to_usb_boot(0, 0);
+
+        #[allow(clippy::empty_loop)]
         loop {}
     }
 
@@ -474,7 +485,7 @@ pub async fn update_button_state_task(
         };
 
         if let Some(override_state) = &override_stick_state {
-            let mut overriden_gcc_state = gcc_state.clone();
+            let mut overriden_gcc_state = gcc_state;
             match override_state.which_stick {
                 Stick::ControlStick => {
                     overriden_gcc_state.stick_x = override_state.x;
@@ -561,20 +572,20 @@ pub async fn update_stick_states_task(
             }
         }
 
-        match Instant::now() {
+        {
-            n => {
+            let n = Instant::now();
-                match (n - last_loop_time).as_micros() {
+
-                    a if a > 1666 => debug!("Loop took {} us", a),
+            match (n - last_loop_time).as_micros() {
-                    _ => {}
+                a if a > 1666 => debug!("Loop took {} us", a),
-                };
+                _ => {}
-                last_loop_time = n;
+            };
-            }
+            last_loop_time = n;
         };
 
         SIGNAL_STICK_STATE.signal(current_stick_state.clone());
 
-        ticker.next().await;
         yield_now().await;
+        ticker.next().await;
 
         if let Some(new_config) = SIGNAL_CONFIG_CHANGE.try_take() {
             controller_config = new_config;

src/stick.rs

@@ -19,7 +19,7 @@ pub const NO_OF_CALIBRATION_POINTS: usize = 32;
 const MAX_ORDER: usize = 20;
 
 /// 28 degrees; this is the max angular deflection of the stick.
-const MAX_STICK_ANGLE: f32 = 0.4886921906;
+const MAX_STICK_ANGLE: f32 = 0.488_692_2;
 
 #[rustfmt::skip]
 //                                                                right        notch 1      up right     notch 2      up           notch 3      up left      notch 4      left         notch 5      down left    notch 6      down         notch 7      down right   notch 8
@@ -123,10 +123,10 @@ impl CleanedCalibrationPoints {
             out.cleaned_points.x[i + 1] = cal_points_x[i * 2 + 1];
             out.cleaned_points.y[i + 1] = cal_points_y[i * 2 + 1];
 
-            (out.notch_points.x[i + 1], out.notch_points.y[i + 1]) =
+            (out.notch_points.x[i + 1], out.notch_points.y[i + 1]) = {
-                match calc_stick_values(notch_angles[i]) {
+                let (a, b) = calc_stick_values(notch_angles[i]);
-                    (a, b) => (roundf(a), roundf(b)),
+                (roundf(a), roundf(b))
-                };
+            }
         }
 
         // TODO: put the below in a macro to clean it up a bit, once it's confirmed to work
@@ -186,6 +186,7 @@ impl CleanedCalibrationPoints {
         out.cleaned_points.x[0] /= (NO_OF_NOTCHES - 4) as f32;
         out.cleaned_points.y[0] /= (NO_OF_NOTCHES - 4) as f32;
 
+        #[allow(clippy::needless_range_loop)]
         for i in 0..NO_OF_NOTCHES {
             let delta_x = out.cleaned_points.x[i + 1] - out.cleaned_points.x[0];
             let delta_y = out.cleaned_points.y[i + 1] - out.cleaned_points.y[0];
@@ -241,11 +242,9 @@ impl LinearizedCalibration {
     ///
     /// Generate a fit to linearize the stick response.
     ///
-    /// Inputs:
+    /// Inputs: cleaned points X and Y, (must be 17 points for each of these, the first being the center, the others starting at 3 oclock and going around counterclockwise)
-    ///     cleaned points X and Y, (must be 17 points for each of these, the first being the center, the others starting at 3 oclock and going around counterclockwise)
     ///
-    ///	Outputs:
+    /// Outputs: linearization fit coefficients for X and Y
-    ///		linearization fit coefficients for X and Y
     pub fn from_calibration_points(cleaned_calibration_points: &CleanedCalibrationPoints) -> Self {
         let mut fit_points_x = [0f64; 5];
         let mut fit_points_y = [0f64; 5];
@@ -263,7 +262,7 @@ impl LinearizedCalibration {
         fit_points_x[1] = (in_x[6 + 1] + in_x[10 + 1]) / 2.0f64;
         fit_points_x[2] = in_x[0];
         fit_points_x[3] = (in_x[2 + 1] + in_x[14 + 1]) / 2.0f64;
-        fit_points_x[4] = in_x[0 + 1];
+        fit_points_x[4] = in_x[1];
 
         fit_points_y[0] = in_y[12 + 1];
         fit_points_y[1] = (in_y[10 + 1] + in_y[14 + 1]) / 2.0f64;
@@ -282,8 +281,8 @@ impl LinearizedCalibration {
         let x_zero_error = linearize(fit_points_x[2] as f32, &fit_coeffs_x.map(|e| e as f32));
         let y_zero_error = linearize(fit_points_y[2] as f32, &fit_coeffs_y.map(|e| e as f32));
 
-        fit_coeffs_x[3] = fit_coeffs_x[3] - x_zero_error as f64;
+        fit_coeffs_x[3] -= x_zero_error as f64;
-        fit_coeffs_y[3] = fit_coeffs_y[3] - y_zero_error as f64;
+        fit_coeffs_y[3] -= y_zero_error as f64;
 
         let mut linearized_points_x = [0f32; NO_OF_NOTCHES + 1];
         let mut linearized_points_y = [0f32; NO_OF_NOTCHES + 1];
@@ -376,6 +375,7 @@ impl NotchCalibration {
 
             trace!("The transform matrix is: {:?}", a);
 
+            #[allow(clippy::needless_range_loop)]
             for j in 0..2 {
                 for k in 0..2 {
                     out.affine_coeffs[i - 1][j * 2 + k] = a[j][k];
@@ -721,6 +721,7 @@ fn inverse(in_mat: &[[f32; 3]; 3]) -> [[f32; 3]; 3] {
     out_mat
 }
 
+#[allow(clippy::needless_range_loop)]
 fn matrix_mult(a: &[[f32; 3]; 3], b: &[[f32; 3]; 3]) -> [[f32; 3]; 3] {
     let mut out = [[0f32; 3]; 3];
 
@@ -777,8 +778,8 @@ fn det<const N: usize>(matrix: &[[f64; N]; N]) -> f64 {
 
     let mut p = 1f64;
 
-    for i in 0..N {
+    for (i, elem) in matrix.iter().enumerate().take(N) {
-        p *= matrix[i][i];
+        p *= elem[i];
     }
 
     p * (sign as f64)
@@ -798,9 +799,7 @@ fn trianglize<const N: usize>(matrix: &mut [[f64; N]; N]) -> i32 {
         }
         if max > 0 {
             sign = -sign;
-            let tmp = matrix[i];
+            matrix.swap(i, max);
-            matrix[i] = matrix[max];
-            matrix[max] = tmp;
         }
         if matrix[i][i] == 0. {
             return 0;
@@ -848,11 +847,11 @@ fn fit_curve<const N: usize, const NCOEFFS: usize>(
     for i in 0..N {
         let x = px[i];
         let y = py[i];
-        for j in 0..NCOEFFS * 2 - 1 {
+        for (j, elem) in s.iter_mut().enumerate().take(NCOEFFS * 2 - 1) {
-            s[j] += curve_fit_power(x, j as u32);
+            *elem += curve_fit_power(x, j as u32);
         }
-        for j in 0..NCOEFFS {
+        for (j, elem) in t.iter_mut().enumerate().take(NCOEFFS) {
-            t[j] += y * curve_fit_power(x, j as u32);
+            *elem += y * curve_fit_power(x, j as u32);
         }
     }
 
@@ -860,9 +859,7 @@ fn fit_curve<const N: usize, const NCOEFFS: usize>(
     let mut matrix = [[0f64; NCOEFFS]; NCOEFFS];
 
     for i in 0..NCOEFFS {
-        for j in 0..NCOEFFS {
+        matrix[i][..NCOEFFS].copy_from_slice(&s[i..(NCOEFFS + i)]);
-            matrix[i][j] = s[i + j];
-        }
     }
 
     let denom = det(&matrix);
@@ -893,7 +890,6 @@ pub fn linearize(point: f32, coefficients: &[f32; NUM_COEFFS]) -> f32 {
         + coefficients[3]
 }
 
-// TODO: currently broken!
 #[link_section = ".time_critical.notch_remap"]
 pub fn notch_remap(
     x_in: f32,