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

chore: refactor according to clippy & clean up config #6

Merged
Naxdy merged 8 commits from clippy-fixes into main 2024-04-03 16:53:52 +00:00
Conversation 0 Commits 8 Files changed 5 +694 -619
5 changed files with 694 additions and 619 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
.forgejo/workflows/clippy-check.yml Normal file
View file

@ -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

4
Cargo.toml
View file

@ -72,7 +72,9 @@ debug = 2
debug-assertions = false debug-assertions = false
incremental = false incremental = false
lto = 'fat' 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 overflow-checks = false
# do not optimize proc-macro crates = faster builds from scratch # do not optimize proc-macro crates = faster builds from scratch

513
src/config.rs
View file

@ -13,7 +13,9 @@ use embassy_rp::{
use packed_struct::{derive::PackedStruct, PackedStruct}; use packed_struct::{derive::PackedStruct, PackedStruct};
use crate::{ use crate::{
gcc_hid::{SIGNAL_CHANGE_RUMBLE_STRENGTH, SIGNAL_INPUT_CONSISTENCY_MODE_STATUS}, gcc_hid::{
Buttons1, Buttons2, SIGNAL_CHANGE_RUMBLE_STRENGTH, SIGNAL_INPUT_CONSISTENCY_MODE_STATUS,
},
helpers::{PackedFloat, ToPackedFloatArray, ToRegularArray, XyValuePair}, helpers::{PackedFloat, ToPackedFloatArray, ToRegularArray, XyValuePair},
input::{ input::{
read_ext_adc, Stick, StickAxis, FLOAT_ORIGIN, SPI_ACS_SHARED, SPI_CCS_SHARED, SPI_SHARED, read_ext_adc, Stick, StickAxis, FLOAT_ORIGIN, SPI_ACS_SHARED, SPI_CCS_SHARED, SPI_SHARED,
@ -104,12 +106,12 @@ const LSTICK_SNAPBACK_X_INCREASE_COMBO: [AwaitableButtons; 4] = [
AwaitableButtons::A, AwaitableButtons::A,
AwaitableButtons::X, AwaitableButtons::X,
AwaitableButtons::Up, AwaitableButtons::Up,
AwaitableButtons::Wildcard, AwaitableButtons::NotZ,
]; ];
const LSTICK_SNAPBACK_Y_INCREASE_COMBO: [AwaitableButtons; 4] = [ const LSTICK_SNAPBACK_Y_INCREASE_COMBO: [AwaitableButtons; 4] = [
AwaitableButtons::A, AwaitableButtons::A,
AwaitableButtons::Wildcard, AwaitableButtons::NotZ,
AwaitableButtons::Up, AwaitableButtons::Up,
AwaitableButtons::Y, AwaitableButtons::Y,
]; ];
@ -118,14 +120,14 @@ const LSTICK_SNAPBACK_X_DECREASE_COMBO: [AwaitableButtons; 4] = [
AwaitableButtons::A, AwaitableButtons::A,
AwaitableButtons::X, AwaitableButtons::X,
AwaitableButtons::Down, AwaitableButtons::Down,
AwaitableButtons::Wildcard, AwaitableButtons::NotZ,
]; ];
const LSTICK_SNAPBACK_Y_DECREASE_COMBO: [AwaitableButtons; 4] = [ const LSTICK_SNAPBACK_Y_DECREASE_COMBO: [AwaitableButtons; 4] = [
AwaitableButtons::A, AwaitableButtons::A,
AwaitableButtons::Y, AwaitableButtons::Y,
AwaitableButtons::Down, AwaitableButtons::Down,
AwaitableButtons::Wildcard, AwaitableButtons::NotZ,
]; ];
const RSTICK_SNAPBACK_X_INCREASE_COMBO: [AwaitableButtons; 4] = [ const RSTICK_SNAPBACK_X_INCREASE_COMBO: [AwaitableButtons; 4] = [
@ -159,28 +161,28 @@ const RSTICK_SNAPBACK_Y_DECREASE_COMBO: [AwaitableButtons; 4] = [
const LSTICK_WAVESHAPING_X_INCREASE_COMBO: [AwaitableButtons; 4] = [ const LSTICK_WAVESHAPING_X_INCREASE_COMBO: [AwaitableButtons; 4] = [
AwaitableButtons::X, AwaitableButtons::X,
AwaitableButtons::Up, AwaitableButtons::Up,
AwaitableButtons::Wildcard, AwaitableButtons::NotZ,
AwaitableButtons::L, AwaitableButtons::L,
]; ];
const LSTICK_WAVESHAPING_Y_INCREASE_COMBO: [AwaitableButtons; 4] = [ const LSTICK_WAVESHAPING_Y_INCREASE_COMBO: [AwaitableButtons; 4] = [
AwaitableButtons::Y, AwaitableButtons::Y,
AwaitableButtons::Up, AwaitableButtons::Up,
AwaitableButtons::Wildcard, AwaitableButtons::NotZ,
AwaitableButtons::L, AwaitableButtons::L,
]; ];
const LSTICK_WAVESHAPING_X_DECREASE_COMBO: [AwaitableButtons; 4] = [ const LSTICK_WAVESHAPING_X_DECREASE_COMBO: [AwaitableButtons; 4] = [
AwaitableButtons::X, AwaitableButtons::X,
AwaitableButtons::Down, AwaitableButtons::Down,
AwaitableButtons::Wildcard, AwaitableButtons::NotZ,
AwaitableButtons::L, AwaitableButtons::L,
]; ];
const LSTICK_WAVESHAPING_Y_DECREASE_COMBO: [AwaitableButtons; 4] = [ const LSTICK_WAVESHAPING_Y_DECREASE_COMBO: [AwaitableButtons; 4] = [
AwaitableButtons::Y, AwaitableButtons::Y,
AwaitableButtons::Down, AwaitableButtons::Down,
AwaitableButtons::Wildcard, AwaitableButtons::NotZ,
AwaitableButtons::L, AwaitableButtons::L,
]; ];
@ -216,28 +218,28 @@ const LSTICK_SMOOTH_X_INCREASE_COMBO: [AwaitableButtons; 4] = [
AwaitableButtons::R, AwaitableButtons::R,
AwaitableButtons::X, AwaitableButtons::X,
AwaitableButtons::Up, AwaitableButtons::Up,
AwaitableButtons::Wildcard, AwaitableButtons::NotZ,
]; ];
const LSTICK_SMOOTH_Y_INCREASE_COMBO: [AwaitableButtons; 4] = [ const LSTICK_SMOOTH_Y_INCREASE_COMBO: [AwaitableButtons; 4] = [
AwaitableButtons::R, AwaitableButtons::R,
AwaitableButtons::Y, AwaitableButtons::Y,
AwaitableButtons::Up, AwaitableButtons::Up,
AwaitableButtons::Wildcard, AwaitableButtons::NotZ,
]; ];
const LSTICK_SMOOTH_X_DECREASE_COMBO: [AwaitableButtons; 4] = [ const LSTICK_SMOOTH_X_DECREASE_COMBO: [AwaitableButtons; 4] = [
AwaitableButtons::R, AwaitableButtons::R,
AwaitableButtons::X, AwaitableButtons::X,
AwaitableButtons::Down, AwaitableButtons::Down,
AwaitableButtons::Wildcard, AwaitableButtons::NotZ,
]; ];
const LSTICK_SMOOTH_Y_DECREASE_COMBO: [AwaitableButtons; 4] = [ const LSTICK_SMOOTH_Y_DECREASE_COMBO: [AwaitableButtons; 4] = [
AwaitableButtons::R, AwaitableButtons::R,
AwaitableButtons::Y, AwaitableButtons::Y,
AwaitableButtons::Down, AwaitableButtons::Down,
AwaitableButtons::Wildcard, AwaitableButtons::NotZ,
]; ];
const RSTICK_SMOOTH_X_INCREASE_COMBO: [AwaitableButtons; 4] = [ const RSTICK_SMOOTH_X_INCREASE_COMBO: [AwaitableButtons; 4] = [
@ -272,14 +274,14 @@ const LSTICK_CARDINALSNAP_INCREASE_COMBO: [AwaitableButtons; 4] = [
AwaitableButtons::R, AwaitableButtons::R,
AwaitableButtons::A, AwaitableButtons::A,
AwaitableButtons::Up, AwaitableButtons::Up,
AwaitableButtons::Wildcard, AwaitableButtons::NotZ,
]; ];
const LSTICK_CARDINALSNAP_DECREASE_COMBO: [AwaitableButtons; 4] = [ const LSTICK_CARDINALSNAP_DECREASE_COMBO: [AwaitableButtons; 4] = [
AwaitableButtons::R, AwaitableButtons::R,
AwaitableButtons::A, AwaitableButtons::A,
AwaitableButtons::Down, AwaitableButtons::Down,
AwaitableButtons::Wildcard, AwaitableButtons::NotZ,
]; ];
const RSTICK_CARDINALSNAP_INCREASE_COMBO: [AwaitableButtons; 4] = [ const RSTICK_CARDINALSNAP_INCREASE_COMBO: [AwaitableButtons; 4] = [
@ -300,14 +302,14 @@ const LSTICK_SCALING_INCREASE_COMBO: [AwaitableButtons; 4] = [
AwaitableButtons::L, AwaitableButtons::L,
AwaitableButtons::A, AwaitableButtons::A,
AwaitableButtons::Up, AwaitableButtons::Up,
AwaitableButtons::Wildcard, AwaitableButtons::NotZ,
]; ];
const LSTICK_SCALING_DECREASE_COMBO: [AwaitableButtons; 4] = [ const LSTICK_SCALING_DECREASE_COMBO: [AwaitableButtons; 4] = [
AwaitableButtons::L, AwaitableButtons::L,
AwaitableButtons::A, AwaitableButtons::A,
AwaitableButtons::Down, AwaitableButtons::Down,
AwaitableButtons::Wildcard, AwaitableButtons::NotZ,
]; ];
const RSTICK_SCALING_INCREASE_COMBO: [AwaitableButtons; 4] = [ const RSTICK_SCALING_INCREASE_COMBO: [AwaitableButtons; 4] = [
@ -456,6 +458,8 @@ enum AwaitableButtons {
L, L,
R, R,
Z, Z,
// special, because Z is used for cstick calibration
NotZ,
/// Used for padding arrays to the correct length. /// Used for padding arrays to the correct length.
Wildcard, Wildcard,
/// Used for disabling certain button combinations.\ /// Used for disabling certain button combinations.\
@ -552,17 +556,15 @@ impl Default for ControllerConfig {
impl ControllerConfig { impl ControllerConfig {
pub fn from_flash_memory( pub fn from_flash_memory(
mut flash: &mut Flash<'static, FLASH, Async, FLASH_SIZE>, flash: &mut Flash<'static, FLASH, Async, FLASH_SIZE>,
) -> Result<Self, embassy_rp::flash::Error> { ) -> Result<Self, embassy_rp::flash::Error> {
let mut controller_config_packed: <ControllerConfig as packed_struct::PackedStruct>::ByteArray = ControllerConfig::default().pack().unwrap(); let mut controller_config_packed: <ControllerConfig as packed_struct::PackedStruct>::ByteArray = ControllerConfig::default().pack().unwrap();
let r = flash.blocking_read(ADDR_OFFSET, &mut controller_config_packed); let r = flash.blocking_read(ADDR_OFFSET, &mut controller_config_packed);
if let Err(_) = r { if r.is_err() {
warn!("Controller config not found in flash, using default."); warn!("Controller config not found in flash, using default.");
controller_config_packed = [0u8; 659]; controller_config_packed = [0u8; 659];
} else {
r.unwrap();
} }
match ControllerConfig::unpack(&controller_config_packed) { match ControllerConfig::unpack(&controller_config_packed) {
@ -582,7 +584,7 @@ impl ControllerConfig {
let cfg = ControllerConfig::default(); let cfg = ControllerConfig::default();
info!("Going to save default controller config."); info!("Going to save default controller config.");
cfg.write_to_flash(&mut flash)?; cfg.write_to_flash(flash)?;
Ok(cfg) Ok(cfg)
} }
@ -725,7 +727,7 @@ impl<'a, T: RawMutex, const I: usize, const J: usize, const K: usize> WaitForBut
} }
} }
return None; None
} }
} }
@ -745,6 +747,7 @@ fn is_awaitable_button_pressed(report: &GcReport, button_to_wait_for: &Awaitable
AwaitableButtons::Z => report.buttons_2.button_z, AwaitableButtons::Z => report.buttons_2.button_z,
AwaitableButtons::Wildcard => true, AwaitableButtons::Wildcard => true,
AwaitableButtons::Impossible => false, AwaitableButtons::Impossible => false,
AwaitableButtons::NotZ => !report.buttons_2.button_z,
} }
} }
@ -779,7 +782,9 @@ impl<'a> StickCalibrationProcess<'a> {
if self.applied_calibration.cleaned_calibration.notch_status[notch_idx] if self.applied_calibration.cleaned_calibration.notch_status[notch_idx]
== NotchStatus::TertInactive == NotchStatus::TertInactive
{} {
return;
}
// assumes a tick rate of 1ms // assumes a tick rate of 1ms
match notch_adjustment_type { match notch_adjustment_type {
@ -828,7 +833,7 @@ impl<'a> StickCalibrationProcess<'a> {
stick_config.angles = *legalize_notches( stick_config.angles = *legalize_notches(
self.calibration_step as usize, self.calibration_step as usize,
&self.applied_calibration.measured_notch_angles, &self.applied_calibration.measured_notch_angles,
&stick_config.angles.to_regular_array(), stick_config.angles.to_regular_array(),
) )
.to_packed_float_array(); .to_packed_float_array();
@ -883,7 +888,7 @@ impl<'a> StickCalibrationProcess<'a> {
self.applied_calibration = AppliedCalibration::from_points( self.applied_calibration = AppliedCalibration::from_points(
&self.cal_points.map(|e| e.x), &self.cal_points.map(|e| e.x),
&self.cal_points.map(|e| e.y), &self.cal_points.map(|e| e.y),
&stick_config, stick_config,
); );
stick_config.angles = *legalize_notches( stick_config.angles = *legalize_notches(
@ -907,7 +912,7 @@ impl<'a> StickCalibrationProcess<'a> {
stick_config.angles = *legalize_notches( stick_config.angles = *legalize_notches(
self.calibration_step as usize, self.calibration_step as usize,
&self.applied_calibration.measured_notch_angles, &self.applied_calibration.measured_notch_angles,
&stick_config.angles.to_regular_array(), stick_config.angles.to_regular_array(),
) )
.to_packed_float_array(); .to_packed_float_array();
@ -935,7 +940,7 @@ impl<'a> StickCalibrationProcess<'a> {
SIGNAL_CONFIG_CHANGE.signal(self.gcc_config.clone()); SIGNAL_CONFIG_CHANGE.signal(self.gcc_config.clone());
} }
return false; false
} }
pub async fn calibrate_stick(&mut self) { pub async fn calibrate_stick(&mut self) {
@ -1042,9 +1047,8 @@ fn get_stick_display_coords(current_step: usize) -> (f32, f32) {
let idx = CALIBRATION_ORDER[current_step]; let idx = CALIBRATION_ORDER[current_step];
if idx % 2 != 0 { if idx % 2 != 0 {
let notch_idx = idx / 2; let notch_idx = idx / 2;
match calc_stick_values(DEFAULT_ANGLES[notch_idx]) { let (x, y) = calc_stick_values(DEFAULT_ANGLES[notch_idx]);
(x, y) => (x + FLOAT_ORIGIN, y + FLOAT_ORIGIN), (x + FLOAT_ORIGIN, y + FLOAT_ORIGIN)
}
} else { } else {
(127.5, 127.5) (127.5, 127.5)
} }
@ -1063,7 +1067,7 @@ async fn configuration_main_loop<
const P: usize, const P: usize,
>( >(
current_config: &ControllerConfig, current_config: &ControllerConfig,
mut flash: &mut Flash<'static, FLASH, Async, FLASH_SIZE>, flash: &mut Flash<'static, FLASH, Async, FLASH_SIZE>,
gcc_subscriber: &mut Subscriber<'a, M, GcReport, C, S, P>, gcc_subscriber: &mut Subscriber<'a, M, GcReport, C, S, P>,
) -> ControllerConfig { ) -> ControllerConfig {
let mut final_config = current_config.clone(); let mut final_config = current_config.clone();
@ -1112,29 +1116,31 @@ async fn configuration_main_loop<
]; ];
'main: loop { 'main: loop {
match gcc_subscriber let selection = gcc_subscriber
.wait_and_filter_simultaneous_button_presses(&config_options) .wait_and_filter_simultaneous_button_presses(&config_options)
.await .await;
{ match selection {
selection => match selection {
// exit // exit
0 => { 0 => {
override_gcc_state_and_wait(&OverrideGcReportInstruction { override_gcc_state_and_wait(&OverrideGcReportInstruction {
report: match GcReport::default() { report: GcReport {
mut a => { trigger_r: 255,
a.trigger_r = 255; trigger_l: 255,
a.trigger_l = 255; buttons_2: Buttons2 {
a.buttons_2.button_l = true; button_r: true,
a.buttons_2.button_r = true; button_l: true,
a.buttons_1.button_x = true; ..Default::default()
a.buttons_1.button_y = true; },
a.buttons_1.button_a = true; buttons_1: Buttons1 {
a.stick_x = 127; button_x: true,
a.stick_y = 127; button_y: true,
a.cstick_x = 127; button_a: true,
a.cstick_y = 127; ..Default::default()
a },
} stick_x: 127,
stick_y: 127,
cstick_x: 127,
cstick_y: 127,
}, },
duration_ms: 1000, duration_ms: 1000,
}) })
@ -1145,20 +1151,24 @@ async fn configuration_main_loop<
// calibrate lstick // calibrate lstick
1 => { 1 => {
override_gcc_state_and_wait(&OverrideGcReportInstruction { override_gcc_state_and_wait(&OverrideGcReportInstruction {
report: match GcReport::default() { report: GcReport {
mut a => { trigger_r: 255,
a.trigger_r = 255; trigger_l: 255,
a.trigger_l = 255; buttons_2: Buttons2 {
a.buttons_2.button_r = true; button_r: true,
a.buttons_2.button_l = true; button_l: true,
a.buttons_1.button_x = true; ..Default::default()
a.buttons_1.button_a = true; },
a.stick_x = 255; buttons_1: Buttons1 {
a.stick_y = 255; button_x: true,
a.cstick_x = 127; button_y: true,
a.cstick_y = 127; button_a: true,
a ..Default::default()
} },
stick_x: 255,
stick_y: 255,
cstick_x: 127,
cstick_y: 127,
}, },
duration_ms: 1000, duration_ms: 1000,
}) })
@ -1170,20 +1180,24 @@ async fn configuration_main_loop<
// calibrate rstick // calibrate rstick
2 => { 2 => {
override_gcc_state_and_wait(&OverrideGcReportInstruction { override_gcc_state_and_wait(&OverrideGcReportInstruction {
report: match GcReport::default() { report: GcReport {
mut a => { trigger_r: 255,
a.trigger_r = 255; trigger_l: 255,
a.trigger_l = 255; buttons_2: Buttons2 {
a.buttons_2.button_r = true; button_r: true,
a.buttons_2.button_l = true; button_l: true,
a.buttons_1.button_x = true; ..Default::default()
a.buttons_1.button_a = true; },
a.stick_x = 127; buttons_1: Buttons1 {
a.stick_y = 127; button_x: true,
a.cstick_x = 255; button_y: true,
a.cstick_y = 255; button_a: true,
a ..Default::default()
} },
stick_x: 127,
stick_y: 127,
cstick_x: 255,
cstick_y: 255,
}, },
duration_ms: 1000, duration_ms: 1000,
}) })
@ -1193,10 +1207,10 @@ async fn configuration_main_loop<
.await; .await;
} }
// snapback changes // snapback changes
i if i >= 3 && i <= 10 => { i if (3..=10).contains(&i) => {
let stick = match i { let stick = match i {
3 | 4 | 5 | 6 => Stick::ControlStick, 3..=6 => Stick::ControlStick,
7 | 8 | 9 | 10 => Stick::CStick, 7..=10 => Stick::CStick,
_ => unreachable!(), _ => unreachable!(),
}; };
@ -1225,48 +1239,52 @@ async fn configuration_main_loop<
.clamp(-ABS_MAX_SNAPBACK, ABS_MAX_SNAPBACK); .clamp(-ABS_MAX_SNAPBACK, ABS_MAX_SNAPBACK);
override_gcc_state_and_wait(&OverrideGcReportInstruction { override_gcc_state_and_wait(&OverrideGcReportInstruction {
report: match GcReport::default() { report: GcReport {
mut a => { trigger_r: 255,
a.trigger_r = 255; trigger_l: 255,
a.trigger_l = 255; buttons_2: Buttons2 {
a.buttons_2.button_r = true; button_r: true,
a.buttons_2.button_l = true; button_l: true,
a.buttons_1.button_x = true; ..Default::default()
a.buttons_1.button_a = true; },
a.stick_x = (127 buttons_1: Buttons1 {
button_x: true,
button_y: true,
button_a: true,
..Default::default()
},
stick_x: (127
+ match stick { + match stick {
Stick::ControlStick => match axis { Stick::ControlStick => match axis {
StickAxis::XAxis => *to_adjust, StickAxis::XAxis => *to_adjust,
StickAxis::YAxis => 0, StickAxis::YAxis => 0,
}, },
Stick::CStick => 0, Stick::CStick => 0,
}) as u8; }) as u8,
a.stick_y = (127 stick_y: (127
+ match stick { + match stick {
Stick::ControlStick => match axis { Stick::ControlStick => match axis {
StickAxis::XAxis => 0, StickAxis::XAxis => 0,
StickAxis::YAxis => *to_adjust, StickAxis::YAxis => *to_adjust,
}, },
Stick::CStick => 0, Stick::CStick => 0,
}) as u8; }) as u8,
a.cstick_x = (127 cstick_x: (127
+ match stick { + match stick {
Stick::ControlStick => 0, Stick::ControlStick => 0,
Stick::CStick => match axis { Stick::CStick => match axis {
StickAxis::XAxis => *to_adjust, StickAxis::XAxis => *to_adjust,
StickAxis::YAxis => 0, StickAxis::YAxis => 0,
}, },
}) as u8; }) as u8,
a.cstick_y = (127 cstick_y: (127
+ match stick { + match stick {
Stick::ControlStick => 0, Stick::ControlStick => 0,
Stick::CStick => match axis { Stick::CStick => match axis {
StickAxis::XAxis => 0, StickAxis::XAxis => 0,
StickAxis::YAxis => *to_adjust, StickAxis::YAxis => *to_adjust,
}, },
}) as u8; }) as u8,
a
}
}, },
duration_ms: 750, duration_ms: 750,
}) })
@ -1275,10 +1293,10 @@ async fn configuration_main_loop<
SIGNAL_CONFIG_CHANGE.signal(final_config.clone()); SIGNAL_CONFIG_CHANGE.signal(final_config.clone());
} }
// waveshaping changes // waveshaping changes
i if i >= 11 && i <= 18 => { i if (11..=18).contains(&i) => {
let stick = match i { let stick = match i {
11 | 12 | 13 | 14 => Stick::ControlStick, 11..=14 => Stick::ControlStick,
15 | 16 | 17 | 18 => Stick::CStick, 15..=18 => Stick::CStick,
_ => unreachable!(), _ => unreachable!(),
}; };
@ -1307,48 +1325,52 @@ async fn configuration_main_loop<
.clamp(0, MAX_WAVESHAPING) as u8; .clamp(0, MAX_WAVESHAPING) as u8;
override_gcc_state_and_wait(&OverrideGcReportInstruction { override_gcc_state_and_wait(&OverrideGcReportInstruction {
report: match GcReport::default() { report: GcReport {
mut a => { trigger_r: 255,
a.trigger_r = 255; trigger_l: 255,
a.trigger_l = 255; buttons_2: Buttons2 {
a.buttons_2.button_r = true; button_r: true,
a.buttons_2.button_l = true; button_l: true,
a.buttons_1.button_x = true; ..Default::default()
a.buttons_1.button_a = true; },
a.stick_x = (127 buttons_1: Buttons1 {
button_x: true,
button_y: true,
button_a: true,
..Default::default()
},
stick_x: (127
+ match stick { + match stick {
Stick::ControlStick => match axis { Stick::ControlStick => match axis {
StickAxis::XAxis => *to_adjust, StickAxis::XAxis => *to_adjust,
StickAxis::YAxis => 0, StickAxis::YAxis => 0,
}, },
Stick::CStick => 0, Stick::CStick => 0,
}) as u8; }) as u8,
a.stick_y = (127 stick_y: (127
+ match stick { + match stick {
Stick::ControlStick => match axis { Stick::ControlStick => match axis {
StickAxis::XAxis => 0, StickAxis::XAxis => 0,
StickAxis::YAxis => *to_adjust, StickAxis::YAxis => *to_adjust,
}, },
Stick::CStick => 0, Stick::CStick => 0,
}) as u8; }) as u8,
a.cstick_x = (127 cstick_x: (127
+ match stick { + match stick {
Stick::ControlStick => 0, Stick::ControlStick => 0,
Stick::CStick => match axis { Stick::CStick => match axis {
StickAxis::XAxis => *to_adjust, StickAxis::XAxis => *to_adjust,
StickAxis::YAxis => 0, StickAxis::YAxis => 0,
}, },
}) as u8; }) as u8,
a.cstick_y = (127 cstick_y: (127
+ match stick { + match stick {
Stick::ControlStick => 0, Stick::ControlStick => 0,
Stick::CStick => match axis { Stick::CStick => match axis {
StickAxis::XAxis => 0, StickAxis::XAxis => 0,
StickAxis::YAxis => *to_adjust, StickAxis::YAxis => *to_adjust,
}, },
}) as u8; }) as u8,
a
}
}, },
duration_ms: 750, duration_ms: 750,
}) })
@ -1357,10 +1379,10 @@ async fn configuration_main_loop<
SIGNAL_CONFIG_CHANGE.signal(final_config.clone()); SIGNAL_CONFIG_CHANGE.signal(final_config.clone());
} }
// smoothing changes // smoothing changes
i if i >= 19 && i <= 26 => { i if (19..=26).contains(&i) => {
let stick = match i { let stick = match i {
19 | 20 | 21 | 22 => Stick::ControlStick, 19..=22 => Stick::ControlStick,
23 | 24 | 25 | 26 => Stick::CStick, 23..=26 => Stick::CStick,
_ => unreachable!(), _ => unreachable!(),
}; };
@ -1389,48 +1411,52 @@ async fn configuration_main_loop<
.clamp(0, MAX_SMOOTHING) as u8; .clamp(0, MAX_SMOOTHING) as u8;
override_gcc_state_and_wait(&OverrideGcReportInstruction { override_gcc_state_and_wait(&OverrideGcReportInstruction {
report: match GcReport::default() { report: GcReport {
mut a => { trigger_r: 255,
a.trigger_r = 255; trigger_l: 255,
a.trigger_l = 255; buttons_2: Buttons2 {
a.buttons_2.button_r = true; button_r: true,
a.buttons_2.button_l = true; button_l: true,
a.buttons_1.button_x = true; ..Default::default()
a.buttons_1.button_a = true; },
a.stick_x = (127 buttons_1: Buttons1 {
button_x: true,
button_y: true,
button_a: true,
..Default::default()
},
stick_x: (127
+ match stick { + match stick {
Stick::ControlStick => match axis { Stick::ControlStick => match axis {
StickAxis::XAxis => *to_adjust, StickAxis::XAxis => *to_adjust,
StickAxis::YAxis => 0, StickAxis::YAxis => 0,
}, },
Stick::CStick => 0, Stick::CStick => 0,
}) as u8; }) as u8,
a.stick_y = (127 stick_y: (127
+ match stick { + match stick {
Stick::ControlStick => match axis { Stick::ControlStick => match axis {
StickAxis::XAxis => 0, StickAxis::XAxis => 0,
StickAxis::YAxis => *to_adjust, StickAxis::YAxis => *to_adjust,
}, },
Stick::CStick => 0, Stick::CStick => 0,
}) as u8; }) as u8,
a.cstick_x = (127 cstick_x: (127
+ match stick { + match stick {
Stick::ControlStick => 0, Stick::ControlStick => 0,
Stick::CStick => match axis { Stick::CStick => match axis {
StickAxis::XAxis => *to_adjust, StickAxis::XAxis => *to_adjust,
StickAxis::YAxis => 0, StickAxis::YAxis => 0,
}, },
}) as u8; }) as u8,
a.cstick_y = (127 cstick_y: (127
+ match stick { + match stick {
Stick::ControlStick => 0, Stick::ControlStick => 0,
Stick::CStick => match axis { Stick::CStick => match axis {
StickAxis::XAxis => 0, StickAxis::XAxis => 0,
StickAxis::YAxis => *to_adjust, StickAxis::YAxis => *to_adjust,
}, },
}) as u8; }) as u8,
a
}
}, },
duration_ms: 750, duration_ms: 750,
}) })
@ -1439,17 +1465,16 @@ async fn configuration_main_loop<
SIGNAL_CONFIG_CHANGE.signal(final_config.clone()); SIGNAL_CONFIG_CHANGE.signal(final_config.clone());
} }
// cardinalsnap increase/decrease // cardinalsnap increase/decrease
i if i >= 27 && i <= 30 => { i if (27..=30).contains(&i) => {
let stick = match i { let stick = match i {
27 | 28 => Stick::ControlStick, 27 | 28 => Stick::ControlStick,
29 | 30 => Stick::CStick, 29 | 30 => Stick::CStick,
_ => unreachable!(), _ => unreachable!(),
}; };
let to_adjust = match i { let to_adjust = match stick {
27 | 29 => &mut final_config.astick_config.cardinal_snapping, Stick::ControlStick => &mut final_config.astick_config.cardinal_snapping,
28 | 30 => &mut final_config.cstick_config.cardinal_snapping, Stick::CStick => &mut final_config.cstick_config.cardinal_snapping,
_ => unreachable!(),
}; };
*to_adjust = (*to_adjust *to_adjust = (*to_adjust
@ -1461,28 +1486,32 @@ async fn configuration_main_loop<
.clamp(-1, MAX_CARDINAL_SNAP); .clamp(-1, MAX_CARDINAL_SNAP);
override_gcc_state_and_wait(&OverrideGcReportInstruction { override_gcc_state_and_wait(&OverrideGcReportInstruction {
report: match GcReport::default() { report: GcReport {
mut a => { trigger_r: 255,
a.trigger_r = 255; trigger_l: 255,
a.trigger_l = 255; buttons_2: Buttons2 {
a.buttons_2.button_r = true; button_r: true,
a.buttons_2.button_l = true; button_l: true,
a.buttons_1.button_x = true; ..Default::default()
a.buttons_1.button_a = true; },
a.stick_x = 127; buttons_1: Buttons1 {
a.stick_y = (127 button_x: true,
button_y: true,
button_a: true,
..Default::default()
},
stick_x: 127,
stick_y: (127
+ match stick { + match stick {
Stick::ControlStick => *to_adjust, Stick::ControlStick => *to_adjust,
Stick::CStick => 0, Stick::CStick => 0,
}) as u8; }) as u8,
a.cstick_x = 127; cstick_x: 127,
a.cstick_y = (127 cstick_y: (127
+ match stick { + match stick {
Stick::ControlStick => 0, Stick::ControlStick => 0,
Stick::CStick => *to_adjust, Stick::CStick => *to_adjust,
}) as u8; }) as u8,
a
}
}, },
duration_ms: 750, duration_ms: 750,
}) })
@ -1491,50 +1520,54 @@ async fn configuration_main_loop<
SIGNAL_CONFIG_CHANGE.signal(final_config.clone()); SIGNAL_CONFIG_CHANGE.signal(final_config.clone());
} }
// scaling changes // scaling changes
i if i >= 31 && i <= 34 => { i if (31..=34).contains(&i) => {
let stick = match i { let stick = match i {
31 | 32 => Stick::ControlStick, 31 | 32 => Stick::ControlStick,
33 | 34 => Stick::CStick, 33 | 34 => Stick::CStick,
_ => unreachable!(), _ => unreachable!(),
}; };
let to_adjust = match i { let to_adjust = match stick {
31 | 33 => &mut final_config.astick_config.analog_scaler, Stick::ControlStick => &mut final_config.astick_config.analog_scaler,
32 | 34 => &mut final_config.cstick_config.analog_scaler, Stick::CStick => &mut final_config.cstick_config.analog_scaler,
_ => unreachable!(),
}; };
*to_adjust = ((*to_adjust as i8 *to_adjust = (*to_adjust as i8
+ match i { + match i {
31 | 33 => 1, 31 | 33 => 1,
32 | 34 => -1, 32 | 34 => -1,
_ => unreachable!(), _ => unreachable!(),
}) as u8) })
.clamp(MIN_ANALOG_SCALER, MAX_ANALOG_SCALER); .clamp(MIN_ANALOG_SCALER as i8, MAX_ANALOG_SCALER as i8)
as u8;
override_gcc_state_and_wait(&OverrideGcReportInstruction { override_gcc_state_and_wait(&OverrideGcReportInstruction {
report: match GcReport::default() { report: GcReport {
mut a => { trigger_r: 255,
a.trigger_r = 255; trigger_l: 255,
a.trigger_l = 255; buttons_2: Buttons2 {
a.buttons_2.button_r = true; button_r: true,
a.buttons_2.button_l = true; button_l: true,
a.buttons_1.button_x = true; ..Default::default()
a.buttons_1.button_a = true; },
a.stick_x = 127; buttons_1: Buttons1 {
a.stick_y = (127 button_x: true,
button_y: true,
button_a: true,
..Default::default()
},
stick_x: 127,
stick_y: (127
+ match stick { + match stick {
Stick::ControlStick => *to_adjust, Stick::ControlStick => *to_adjust,
Stick::CStick => 0, Stick::CStick => 0,
}) as u8; }) as u8,
a.cstick_x = 127; cstick_x: 127,
a.cstick_y = (127 cstick_y: (127
+ match stick { + match stick {
Stick::ControlStick => 0, Stick::ControlStick => 0,
Stick::CStick => *to_adjust, Stick::CStick => *to_adjust,
}) as u8; }) as u8,
a
}
}, },
duration_ms: 750, duration_ms: 750,
}) })
@ -1543,7 +1576,7 @@ async fn configuration_main_loop<
SIGNAL_CONFIG_CHANGE.signal(final_config.clone()); SIGNAL_CONFIG_CHANGE.signal(final_config.clone());
} }
// rumble strength changes // rumble strength changes
i if i >= 35 && i <= 36 => { i if (35..=36).contains(&i) => {
let to_adjust = &mut final_config.rumble_strength; let to_adjust = &mut final_config.rumble_strength;
*to_adjust = (*to_adjust as i8 *to_adjust = (*to_adjust as i8
@ -1557,21 +1590,25 @@ async fn configuration_main_loop<
SIGNAL_CHANGE_RUMBLE_STRENGTH.signal(*to_adjust); SIGNAL_CHANGE_RUMBLE_STRENGTH.signal(*to_adjust);
override_gcc_state_and_wait(&OverrideGcReportInstruction { override_gcc_state_and_wait(&OverrideGcReportInstruction {
report: match GcReport::default() { report: GcReport {
mut a => { trigger_r: 255,
a.trigger_r = 255; trigger_l: 255,
a.trigger_l = 255; buttons_2: Buttons2 {
a.buttons_2.button_r = true; button_r: true,
a.buttons_2.button_l = true; button_l: true,
a.buttons_1.button_x = true; button_z: true,
a.buttons_1.button_a = true; ..Default::default()
a.buttons_2.button_z = true; // makes the controller rumble in smashscope },
a.stick_x = 127; buttons_1: Buttons1 {
a.stick_y = 127; button_x: true,
a.cstick_x = 127; button_y: true,
a.cstick_y = 127; button_a: true,
a ..Default::default()
} },
stick_x: 127,
stick_y: 127,
cstick_x: 127,
cstick_y: 127,
}, },
duration_ms: 750, duration_ms: 750,
}) })
@ -1584,24 +1621,28 @@ async fn configuration_main_loop<
final_config.input_consistency_mode = !final_config.input_consistency_mode; final_config.input_consistency_mode = !final_config.input_consistency_mode;
override_gcc_state_and_wait(&OverrideGcReportInstruction { override_gcc_state_and_wait(&OverrideGcReportInstruction {
report: match GcReport::default() { report: GcReport {
mut a => { trigger_r: 255,
a.trigger_r = 255; trigger_l: 255,
a.trigger_l = 255; buttons_2: Buttons2 {
a.buttons_2.button_r = true; button_r: true,
a.buttons_2.button_l = true; button_l: true,
a.buttons_1.button_x = true; ..Default::default()
a.buttons_1.button_a = true; },
a.stick_x = 127; buttons_1: Buttons1 {
a.stick_y = (127 as i8 button_x: true,
button_y: true,
button_a: true,
..Default::default()
},
stick_x: 127,
stick_y: (127_i8
+ match final_config.input_consistency_mode { + match final_config.input_consistency_mode {
true => 69, true => 69,
false => -69, false => -69,
}) as u8; }) as u8,
a.cstick_x = 127; cstick_x: 127,
a.cstick_y = 127; cstick_y: 127,
a
}
}, },
duration_ms: 750, duration_ms: 750,
}) })
@ -1613,10 +1654,9 @@ async fn configuration_main_loop<
error!("Invalid selection in config loop: {}", s); error!("Invalid selection in config loop: {}", s);
continue; continue;
} }
},
}; };
final_config.write_to_flash(&mut flash).unwrap(); final_config.write_to_flash(flash).unwrap();
} }
info!("Exiting config main loop."); info!("Exiting config main loop.");
@ -1654,21 +1694,24 @@ pub async fn config_task(mut flash: Flash<'static, FLASH, Async, FLASH_SIZE>) {
info!("Entering config mode."); info!("Entering config mode.");
override_gcc_state_and_wait(&OverrideGcReportInstruction { override_gcc_state_and_wait(&OverrideGcReportInstruction {
report: match GcReport::default() { report: GcReport {
mut a => { trigger_r: 255,
a.trigger_r = 255; trigger_l: 255,
a.trigger_l = 255; buttons_2: Buttons2 {
a.buttons_2.button_l = true; button_l: true,
a.buttons_2.button_r = true; button_r: true,
a.buttons_1.button_x = true; ..Default::default()
a.buttons_1.button_y = true; },
a.buttons_1.button_a = true; buttons_1: Buttons1 {
a.stick_x = 127; button_x: true,
a.stick_y = 127; button_y: true,
a.cstick_x = 127; button_a: true,
a.cstick_y = 127; ..Default::default()
a },
} stick_x: 127,
stick_y: 127,
cstick_x: 127,
cstick_y: 127,
}, },
duration_ms: 1000, duration_ms: 1000,
}) })

73
src/input.rs
View file

@ -117,11 +117,12 @@ pub fn read_ext_adc<
spi_ccs.set_high(); spi_ccs.set_high();
} }
return temp_value; temp_value
} }
/// 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,
@ -198,17 +199,18 @@ async fn update_stick_states(
trace!("Raw Stick Values 001: {:?}", raw_stick_values); trace!("Raw Stick Values 001: {:?}", raw_stick_values);
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 = {
let (x, y) = run_waveshaping(
x_pos_filt, x_pos_filt,
y_pos_filt, y_pos_filt,
controller_config.astick_config.x_waveshaping, controller_config.astick_config.x_waveshaping,
controller_config.astick_config.y_waveshaping, controller_config.astick_config.y_waveshaping,
controlstick_waveshaping_values, controlstick_waveshaping_values,
&filter_gains, 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 = {
let (x, y) = run_waveshaping(
pos_cx, pos_cx,
pos_cy, pos_cy,
controller_config.cstick_config.x_waveshaping, controller_config.cstick_config.x_waveshaping,
controller_config.cstick_config.y_waveshaping, controller_config.cstick_config.y_waveshaping,
cstick_waveshaping_values, cstick_waveshaping_values,
&filter_gains, 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 = {
let (x, y) = notch_remap(
pos_x, pos_x,
pos_y, pos_y,
controlstick_params, controlstick_params,
&controller_config.astick_config, &controller_config.astick_config,
is_calibrating, is_calibrating,
) { );
(x, y) => XyValuePair { x, y }, XyValuePair { x, y }
}; };
let mut remapped_c = match notch_remap( let mut remapped_c = {
let (x, y) = notch_remap(
pos_cx_filt, pos_cx_filt,
pos_cy_filt, pos_cy_filt,
cstick_params, cstick_params,
&controller_config.cstick_config, &controller_config.cstick_config,
is_calibrating, is_calibrating,
) { );
(x, y) => XyValuePair { x, y }, XyValuePair { x, y }
}; };
let remapped_unfiltered = match notch_remap( let remapped_unfiltered = {
let (x, y) = notch_remap(
raw_stick_values.a_linearized.x, raw_stick_values.a_linearized.x,
raw_stick_values.a_linearized.y, raw_stick_values.a_linearized.y,
controlstick_params, controlstick_params,
&controller_config.astick_config, &controller_config.astick_config,
is_calibrating, is_calibrating,
) { );
(x, y) => XyValuePair { x, y }, XyValuePair { x, y }
}; };
let remapped_c_unfiltered = match notch_remap( let remapped_c_unfiltered = {
let (x, y) = notch_remap(
raw_stick_values.c_linearized.x, raw_stick_values.c_linearized.x,
raw_stick_values.c_linearized.y, raw_stick_values.c_linearized.y,
cstick_params, cstick_params,
&controller_config.cstick_config, &controller_config.cstick_config,
is_calibrating, is_calibrating,
) { );
(x, y) => XyValuePair { x, y }, XyValuePair { x, y }
}; };
trace!( trace!(
@ -309,20 +316,20 @@ async fn update_stick_states(
let mut out_stick_state = current_stick_state.clone(); let mut out_stick_state = current_stick_state.clone();
let diff_x = (remapped.x + FLOAT_ORIGIN) - current_stick_state.ax as f32; 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; out_stick_state.ax = (remapped.x + FLOAT_ORIGIN) as u8;
} }
let diff_y = (remapped.y + FLOAT_ORIGIN) - current_stick_state.ay as f32; 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; out_stick_state.ay = (remapped.y + FLOAT_ORIGIN) as u8;
} }
let diff_cx = (remapped_c.x + FLOAT_ORIGIN) - current_stick_state.cx as f32; 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; 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; 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; out_stick_state.cy = (remapped_c.y + FLOAT_ORIGIN) as u8;
} }
@ -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 {}
} }
@ -474,7 +485,7 @@ pub async fn update_button_state_task(
}; };
if let Some(override_state) = &override_stick_state { 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 { match override_state.which_stick {
Stick::ControlStick => { Stick::ControlStick => {
overriden_gcc_state.stick_x = override_state.x; 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() { match (n - last_loop_time).as_micros() {
a if a > 1666 => debug!("Loop took {} us", a), 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());
ticker.next().await;
yield_now().await; yield_now().await;
ticker.next().await;
if let Some(new_config) = SIGNAL_CONFIG_CHANGE.try_take() { if let Some(new_config) = SIGNAL_CONFIG_CHANGE.try_take() {
controller_config = new_config; controller_config = new_config;

46
src/stick.rs
View file

@ -19,7 +19,7 @@ pub const NO_OF_CALIBRATION_POINTS: usize = 32;
const MAX_ORDER: usize = 20; const MAX_ORDER: usize = 20;
/// 28 degrees; this is the max angular deflection of the stick. /// 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] #[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 // 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.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];
@ -263,7 +262,7 @@ impl LinearizedCalibration {
fit_points_x[1] = (in_x[6 + 1] + in_x[10 + 1]) / 2.0f64; fit_points_x[1] = (in_x[6 + 1] + in_x[10 + 1]) / 2.0f64;
fit_points_x[2] = in_x[0]; fit_points_x[2] = in_x[0];
fit_points_x[3] = (in_x[2 + 1] + in_x[14 + 1]) / 2.0f64; 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[0] = in_y[12 + 1];
fit_points_y[1] = (in_y[10 + 1] + in_y[14 + 1]) / 2.0f64; 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 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)); 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_x = [0f32; NO_OF_NOTCHES + 1];
let mut linearized_points_y = [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); 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)
@ -798,9 +799,7 @@ fn trianglize<const N: usize>(matrix: &mut [[f64; N]; N]) -> i32 {
} }
if max > 0 { if max > 0 {
sign = -sign; sign = -sign;
let tmp = matrix[i]; matrix.swap(i, max);
matrix[i] = matrix[max];
matrix[max] = tmp;
} }
if matrix[i][i] == 0. { if matrix[i][i] == 0. {
return 0; return 0;
@ -848,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);
} }
} }
@ -860,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);
@ -893,7 +890,6 @@ pub fn linearize(point: f32, coefficients: &[f32; NUM_COEFFS]) -> f32 {
+ coefficients[3] + coefficients[3]
} }
// TODO: currently broken!
#[link_section = ".time_critical.notch_remap"] #[link_section = ".time_critical.notch_remap"]
pub fn notch_remap( pub fn notch_remap(
x_in: f32, x_in: f32,