NaxdyOrg/NaxGCC-FW
2
0
Fork 2
Code Issues Pull requests 1 Releases 4 Activity Actions

clippy(project): apply manual suggestions

Browse source
This commit is contained in:
Naxdy 2024-04-03 17:58:43 +02:00
parent 4fce6d6132
commit ead9156400
Signed by: Naxdy
GPG key ID: CC15075846BCE91B
3 changed files with 625 additions and 576 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1041
src/config.rs
View file

File diff suppressed because it is too large Load diff

127
src/input.rs
View file

@ -122,6 +122,7 @@ pub fn read_ext_adc<
/// Gets the average stick state over a 1ms interval in a non-blocking fashion. /// 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. /// 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"] #[link_section = ".time_critical.update_stick_states"]
async fn update_stick_states( async fn update_stick_states(
current_stick_state: &StickState, current_stick_state: &StickState,
@ -200,15 +201,16 @@ async fn update_stick_states(
let (x_pos_filt, y_pos_filt) = 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); trace!("Shaped Controlstick: {}", shaped_astick);
@ -220,15 +222,16 @@ async fn update_stick_states(
old_stick_pos.x = pos_x; old_stick_pos.x = pos_x;
old_stick_pos.y = pos_y; 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 { let old_c_pos = XyValuePair {
@ -250,41 +253,45 @@ async fn update_stick_states(
trace!("Cstick position: {}, {}", pos_cx, pos_cy); 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!( trace!(
@ -337,6 +344,7 @@ async fn update_stick_states(
out_stick_state out_stick_state
} }
#[allow(clippy::too_many_arguments)]
fn update_button_states< fn update_button_states<
A: Pin, A: Pin,
B: Pin, B: Pin,
@ -405,6 +413,7 @@ pub async fn input_integrity_benchmark() {
/// Task responsible for updating the button states. /// Task responsible for updating the button states.
/// Publishes the result to CHANNEL_GCC_STATE. /// Publishes the result to CHANNEL_GCC_STATE.
#[allow(clippy::too_many_arguments)]
#[embassy_executor::task] #[embassy_executor::task]
pub async fn update_button_state_task( pub async fn update_button_state_task(
btn_z: Input<'static, AnyPin>, 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() { if btn_a.is_low() && btn_x.is_low() && btn_y.is_low() {
info!("Detected reset button press, booting into flash."); info!("Detected reset button press, booting into flash.");
embassy_rp::rom_data::reset_to_usb_boot(0, 0); embassy_rp::rom_data::reset_to_usb_boot(0, 0);
#[allow(clippy::empty_loop)]
loop {} loop {}
} }
@ -561,14 +572,14 @@ 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()); SIGNAL_STICK_STATE.signal(current_stick_state.clone());

33
src/stick.rs
View file

@ -123,10 +123,10 @@ impl CleanedCalibrationPoints {
out.cleaned_points.x[i + 1] = cal_points_x[i * 2 + 1]; 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.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 // 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.x[0] /= (NO_OF_NOTCHES - 4) as f32;
out.cleaned_points.y[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 { for i in 0..NO_OF_NOTCHES {
let delta_x = out.cleaned_points.x[i + 1] - out.cleaned_points.x[0]; 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]; 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. /// 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 { pub fn from_calibration_points(cleaned_calibration_points: &CleanedCalibrationPoints) -> Self {
let mut fit_points_x = [0f64; 5]; let mut fit_points_x = [0f64; 5];
let mut fit_points_y = [0f64; 5]; let mut fit_points_y = [0f64; 5];
@ -376,6 +375,7 @@ impl NotchCalibration {
trace!("The transform matrix is: {:?}", a); trace!("The transform matrix is: {:?}", a);
#[allow(clippy::needless_range_loop)]
for j in 0..2 { for j in 0..2 {
for k in 0..2 { for k in 0..2 {
out.affine_coeffs[i - 1][j * 2 + k] = a[j][k]; 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 out_mat
} }
#[allow(clippy::needless_range_loop)]
fn matrix_mult(a: &[[f32; 3]; 3], b: &[[f32; 3]; 3]) -> [[f32; 3]; 3] { fn matrix_mult(a: &[[f32; 3]; 3], b: &[[f32; 3]; 3]) -> [[f32; 3]; 3] {
let mut out = [[0f32; 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; 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) p * (sign as f64)
@ -846,11 +847,11 @@ fn fit_curve<const N: usize, const NCOEFFS: usize>(
for i in 0..N { for i in 0..N {
let x = px[i]; let x = px[i];
let y = py[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);
} }
} }
@ -858,9 +859,7 @@ fn fit_curve<const N: usize, const NCOEFFS: usize>(
let mut matrix = [[0f64; NCOEFFS]; NCOEFFS]; let mut matrix = [[0f64; NCOEFFS]; NCOEFFS];
for i in 0..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); let denom = det(&matrix);