LUMZ-bioz/bioz-firmware-rs
1
0
Fork 0
mirror of https://github.com/hubaldv/bioz-firmware-rs.git synced 2025-12-06 05:01:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Change multi to sweep.

Browse Source
This commit is contained in:
Hubald Verzijl
2025-11-06 12:13:52 +01:00
parent 3716d7367e
commit f6a88b6d66
2 changed files with 46 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
src/communication.rs
View File

@@ -20,9 +20,9 @@ use postcard_rpc::{
},
};
use bioz_icd_rs::{GetUniqueIdEndpoint, MeasurementPointSet, MultiImpedanceOutputTopic, MultiImpedanceResult, MultiImpedanceStartRequest, PingEndpoint, SetGreenLedEndpoint, SingleImpedanceOutputTopic, SingleImpedanceStartRequest, StartMultiImpedanceEndpoint, StartSingleImpedanceEndpoint, StopMultiImpedanceEndpoint, StopSingleImpedanceEndpoint, BioImpedanceLeadMode, ENDPOINT_LIST, TOPICS_IN_LIST, TOPICS_OUT_LIST};
use bioz_icd_rs::{GetUniqueIdEndpoint, MeasurementPointSet, SweepImpedanceOutputTopic, SweepImpedanceResult, SweepImpedanceStartRequest, PingEndpoint, SetGreenLedEndpoint, SingleImpedanceOutputTopic, SingleImpedanceStartRequest, StartSweepImpedanceEndpoint, StartSingleImpedanceEndpoint, StopImpedanceEndpoint, BioImpedanceLeadMode, ENDPOINT_LIST, TOPICS_IN_LIST, TOPICS_OUT_LIST};
use crate::impedance::{ImpedanceSetupType, RunningMode, IMPEDANCE_CHANNEL_MULTI, IMPEDANCE_CHANNEL_SINGLE};
use crate::impedance::{ImpedanceSetupType, RunningMode, IMPEDANCE_CHANNEL_SWEEP, IMPEDANCE_CHANNEL_SINGLE};
// Postcard RPC types
type AppDriver = usb::Driver<'static, peripherals::USB>;
@@ -70,9 +70,8 @@ define_dispatch! {
| GetUniqueIdEndpoint | blocking | get_unique_id_handler |
| SetGreenLedEndpoint | async | set_green_led_handler |
| StartSingleImpedanceEndpoint | spawn | start_single_impedance_handler |
| StopSingleImpedanceEndpoint | async | stop_single_impedance_handler |
| StartMultiImpedanceEndpoint | spawn | start_multi_impedance_handler |
| StopMultiImpedanceEndpoint | async | stop_multi_impedance_handler |
| StartSweepImpedanceEndpoint | spawn | start_sweep_impedance_handler |
| StopImpedanceEndpoint | async | stop_impedance_handler |
};
topics_in: {
list: TOPICS_IN_LIST;
@@ -198,7 +197,7 @@ pub async fn start_single_impedance_handler(context: SpawnCtx, header: VarHeader
match select(stop_fut, recv_fut).await {
Either::First(_) => {
info!("Stop signal received.");
// info!("Stop signal received.");
break;
}
Either::Second(msg) => {
@@ -220,79 +219,70 @@ pub async fn start_single_impedance_handler(context: SpawnCtx, header: VarHeader
STOP.reset();
}
pub async fn stop_single_impedance_handler(context: &mut Context, _header: VarHeader, _rqst: ()) -> bool {
info!("Stop impedance measurement");
let was_busy = context.impedance_setup.lock().await.running_mode;
if was_busy == RunningMode::SingleFrequency2Lead || was_busy == RunningMode::SingleFrequency4Lead || was_busy == RunningMode::MultiFrequency2Lead(MeasurementPointSet::Eight) || was_busy == RunningMode::MultiFrequency2Lead(MeasurementPointSet::Eighteen) || was_busy == RunningMode::MultiFrequency4Lead(MeasurementPointSet::Eight) || was_busy == RunningMode::MultiFrequency4Lead(MeasurementPointSet::Eighteen) {
STOP.signal(());
}
was_busy == RunningMode::SingleFrequency2Lead || was_busy == RunningMode::SingleFrequency4Lead || was_busy == RunningMode::MultiFrequency2Lead(MeasurementPointSet::Eight) || was_busy == RunningMode::MultiFrequency2Lead(MeasurementPointSet::Eighteen) || was_busy == RunningMode::MultiFrequency4Lead(MeasurementPointSet::Eight) || was_busy == RunningMode::MultiFrequency4Lead(MeasurementPointSet::Eighteen)
}
#[embassy_executor::task]
pub async fn start_multi_impedance_handler(context: SpawnCtx, header: VarHeader, rqst: MultiImpedanceStartRequest, sender: Sender<AppTx>) {
pub async fn start_sweep_impedance_handler(context: SpawnCtx, header: VarHeader, rqst: SweepImpedanceStartRequest, sender: Sender<AppTx>) {
// Mark the impedance setup as running
// Init the sequencer
let response = match (rqst.lead_mode, rqst.points) {
(BioImpedanceLeadMode::TwoLead, MeasurementPointSet::Eight) => {
context.impedance_setup.lock().await.running_mode = RunningMode::MultiFrequency2Lead(rqst.points);
context.impedance_setup.lock().await.running_mode = RunningMode::SweepFrequency2Lead(rqst.points);
const SIZE: usize = 8;
context
.impedance_setup
.lock()
.await
.init_multi_frequency_measurement_2_lead::<SIZE>(rqst.points)
.init_sweep_frequency_measurement_2_lead::<SIZE>(rqst.points)
.await
.map(|periods| MultiImpedanceResult {
.map(|periods| SweepImpedanceResult {
points: rqst.points,
periods_per_dft_8: periods,
periods_per_dft_18: Vec::new(),
})
}
(BioImpedanceLeadMode::TwoLead, MeasurementPointSet::Eighteen) => {
context.impedance_setup.lock().await.running_mode = RunningMode::MultiFrequency2Lead(rqst.points);
context.impedance_setup.lock().await.running_mode = RunningMode::SweepFrequency2Lead(rqst.points);
const SIZE: usize = 18;
context
.impedance_setup
.lock()
.await
.init_multi_frequency_measurement_2_lead::<SIZE>(rqst.points)
.init_sweep_frequency_measurement_2_lead::<SIZE>(rqst.points)
.await
.map(|periods| MultiImpedanceResult {
.map(|periods| SweepImpedanceResult {
points: rqst.points,
periods_per_dft_8: Vec::new(),
periods_per_dft_18: periods,
})
}
(BioImpedanceLeadMode::FourLead, MeasurementPointSet::Eight) => {
info!("Start multi impedance 4 lead 8 points");
context.impedance_setup.lock().await.running_mode = RunningMode::MultiFrequency4Lead(rqst.points);
info!("Start impedance spectroscopy 4-lead with 8 points");
context.impedance_setup.lock().await.running_mode = RunningMode::SweepFrequency4Lead(rqst.points);
const SIZE: usize = 8;
context
.impedance_setup
.lock()
.await
.init_multi_frequency_measurement_4_lead::<SIZE>(rqst.points)
.init_sweep_frequency_measurement_4_lead::<SIZE>(rqst.points)
.await
.map(|periods| MultiImpedanceResult {
.map(|periods| SweepImpedanceResult {
points: rqst.points,
periods_per_dft_8: periods,
periods_per_dft_18: Vec::new(),
})
}
(BioImpedanceLeadMode::FourLead, MeasurementPointSet::Eighteen) => {
info!("Start multi impedance 4 lead 18 points");
context.impedance_setup.lock().await.running_mode = RunningMode::MultiFrequency4Lead(rqst.points);
info!("Start impedance spectroscopy 4-lead with 18 points");
context.impedance_setup.lock().await.running_mode = RunningMode::SweepFrequency4Lead(rqst.points);
const SIZE: usize = 18;
context
.impedance_setup
.lock()
.await
.init_multi_frequency_measurement_4_lead::<SIZE>(rqst.points)
.init_sweep_frequency_measurement_4_lead::<SIZE>(rqst.points)
.await
.map(|periods| MultiImpedanceResult {
.map(|periods| SweepImpedanceResult {
points: rqst.points,
periods_per_dft_8: Vec::new(),
periods_per_dft_18: periods,
@@ -304,7 +294,7 @@ pub async fn start_multi_impedance_handler(context: SpawnCtx, header: VarHeader,
context.impedance_setup.lock().await.start_measurement().await;
if sender
.reply::<StartMultiImpedanceEndpoint>(header.seq_no, &response)
.reply::<StartSweepImpedanceEndpoint>(header.seq_no, &response)
.await
.is_err()
{
@@ -312,21 +302,19 @@ pub async fn start_multi_impedance_handler(context: SpawnCtx, header: VarHeader,
return;
}
info!("Start multi impedance measurement.");
let mut seq: u8 = 0;
loop {
let stop_fut = STOP.wait();
let recv_fut = IMPEDANCE_CHANNEL_MULTI.receive();
let recv_fut = IMPEDANCE_CHANNEL_SWEEP.receive();
match select(stop_fut, recv_fut).await {
Either::First(_) => {
info!("Stop signal received.");
// info!("Stop signal received.");
break;
}
Either::Second(msg) => {
if sender
.publish::<MultiImpedanceOutputTopic>(seq.into(), &msg)
.publish::<SweepImpedanceOutputTopic>(seq.into(), &msg)
.await
.is_err()
{
@@ -339,15 +327,15 @@ pub async fn start_multi_impedance_handler(context: SpawnCtx, header: VarHeader,
}
context.impedance_setup.lock().await.running_mode = RunningMode::None;
info!("Impedance measurement stopped.");
info!("Impedance spectroscopy measurement stopped.");
STOP.reset();
}
pub async fn stop_multi_impedance_handler(context: &mut Context, _header: VarHeader, _rqst: ()) -> bool {
pub async fn stop_impedance_handler(context: &mut Context, _header: VarHeader, _rqst: ()) -> bool {
info!("Stop impedance measurement");
let was_busy = context.impedance_setup.lock().await.running_mode;
if was_busy == RunningMode::SingleFrequency2Lead || was_busy == RunningMode::SingleFrequency4Lead || was_busy == RunningMode::MultiFrequency2Lead(MeasurementPointSet::Eight) || was_busy == RunningMode::MultiFrequency2Lead(MeasurementPointSet::Eighteen) || was_busy == RunningMode::MultiFrequency4Lead(MeasurementPointSet::Eight) || was_busy == RunningMode::MultiFrequency4Lead(MeasurementPointSet::Eighteen) {
if was_busy == RunningMode::SingleFrequency2Lead || was_busy == RunningMode::SingleFrequency4Lead || was_busy == RunningMode::SweepFrequency2Lead(MeasurementPointSet::Eight) || was_busy == RunningMode::SweepFrequency2Lead(MeasurementPointSet::Eighteen) || was_busy == RunningMode::SweepFrequency4Lead(MeasurementPointSet::Eight) || was_busy == RunningMode::SweepFrequency4Lead(MeasurementPointSet::Eighteen) {
STOP.signal(());
}
was_busy == RunningMode::SingleFrequency2Lead || was_busy == RunningMode::SingleFrequency4Lead || was_busy == RunningMode::MultiFrequency2Lead(MeasurementPointSet::Eight) || was_busy == RunningMode::MultiFrequency2Lead(MeasurementPointSet::Eighteen) || was_busy == RunningMode::MultiFrequency4Lead(MeasurementPointSet::Eight) || was_busy == RunningMode::MultiFrequency4Lead(MeasurementPointSet::Eighteen)
was_busy == RunningMode::SingleFrequency2Lead || was_busy == RunningMode::SingleFrequency4Lead || was_busy == RunningMode::SweepFrequency2Lead(MeasurementPointSet::Eight) || was_busy == RunningMode::SweepFrequency2Lead(MeasurementPointSet::Eighteen) || was_busy == RunningMode::SweepFrequency4Lead(MeasurementPointSet::Eight) || was_busy == RunningMode::SweepFrequency4Lead(MeasurementPointSet::Eighteen)
}

35
src/impedance.rs
View File

@@ -16,11 +16,11 @@ use num::complex::Complex;
use crate::ad5940::*;
use crate::ad5940_registers::*;
use bioz_icd_rs::{SingleImpedanceOutput, IcdDftNum, ImpedanceInitError, MeasurementPointSet, MultiImpedanceOutput};
use bioz_icd_rs::{SingleImpedanceOutput, IcdDftNum, ImpedanceInitError, MeasurementPointSet, SweepImpedanceOutput};
use crate::icd_mapping::IntoDftnum;
pub static IMPEDANCE_CHANNEL_SINGLE: Channel<ThreadModeRawMutex, SingleImpedanceOutput, 50> = Channel::new();
pub static IMPEDANCE_CHANNEL_MULTI: Channel<ThreadModeRawMutex, MultiImpedanceOutput, 5> = Channel::new();
pub static IMPEDANCE_CHANNEL_SWEEP: Channel<ThreadModeRawMutex, SweepImpedanceOutput, 5> = Channel::new();
pub type ImpedanceSetupType = Mutex<ThreadModeRawMutex, ImpedanceSetup>;
pub static IMPEDANCE_SETUP: StaticCell<ImpedanceSetupType> = StaticCell::new();
@@ -32,8 +32,8 @@ pub enum RunningMode {
None,
SingleFrequency2Lead,
SingleFrequency4Lead,
MultiFrequency2Lead(MeasurementPointSet),
MultiFrequency4Lead(MeasurementPointSet),
SweepFrequency2Lead(MeasurementPointSet),
SweepFrequency4Lead(MeasurementPointSet),
}
pub enum RtiaCalibrated {
@@ -303,7 +303,7 @@ impl ImpedanceSetup {
if let Some(dsp_config) = &self.dsp_config {
wait_time = self.ad5940.sequencer_calculate_wait_time(dsp_config).await.unwrap();
sinus_periods_per_dft = wait_time as f32 / dsp_config.fsys.unwrap() as f32 * frequency as f32;
info!("Sinus periods per DFT: {}", sinus_periods_per_dft);
// info!("Sinus periods per DFT: {}", sinus_periods_per_dft);
} else {
error!("DSP configuration not set, cannot calculate wait time");
return Err(ImpedanceInitError::DSPNotSet);
@@ -385,7 +385,7 @@ impl ImpedanceSetup {
if let Some(dsp_config) = &self.dsp_config {
wait_time = self.ad5940.sequencer_calculate_wait_time(dsp_config).await.unwrap();
sinus_periods_per_dft = wait_time as f32 / dsp_config.fsys.unwrap() as f32 * frequency as f32;
info!("Sinus periods per DFT: {}", sinus_periods_per_dft);
// info!("Sinus periods per DFT: {}", sinus_periods_per_dft);
} else {
error!("DSP configuration not set, cannot calculate wait time");
return Err(ImpedanceInitError::DSPNotSet);
@@ -464,7 +464,7 @@ impl ImpedanceSetup {
Ok(sinus_periods_per_dft)
}
pub async fn init_multi_frequency_measurement_2_lead<const N: usize>(&mut self, number_of_points: MeasurementPointSet) -> Result<heapless::Vec<f32, N>, ImpedanceInitError> {
pub async fn init_sweep_frequency_measurement_2_lead<const N: usize>(&mut self, number_of_points: MeasurementPointSet) -> Result<heapless::Vec<f32, N>, ImpedanceInitError> {
// Configure LP DAC and TIA
self.common_mode_output_enable(false).await.unwrap();
@@ -511,7 +511,7 @@ impl ImpedanceSetup {
let periods_per_dft = wait_time as f32 / dsp_config.fsys.unwrap() as f32 * frequency as f32;
periods_per_dft_vec.push(periods_per_dft).unwrap();
info!("{}Hz: Sinus periods per DFT: {}", frequency, periods_per_dft);
// info!("{}Hz: Sinus periods per DFT: {}", frequency, periods_per_dft);
} else {
error!("DSP configuration not set, cannot calculate wait time");
@@ -572,7 +572,7 @@ impl ImpedanceSetup {
Ok(periods_per_dft_vec)
}
pub async fn init_multi_frequency_measurement_4_lead<const N: usize>(&mut self, number_of_points: MeasurementPointSet) -> Result<heapless::Vec<f32, N>, ImpedanceInitError> {
pub async fn init_sweep_frequency_measurement_4_lead<const N: usize>(&mut self, number_of_points: MeasurementPointSet) -> Result<heapless::Vec<f32, N>, ImpedanceInitError> {
// Configure LP DAC and TIA
self.common_mode_output_enable(true).await.unwrap();
@@ -631,8 +631,7 @@ impl ImpedanceSetup {
let periods_per_dft = wait_time as f32 / dsp_config.fsys.unwrap() as f32 * frequency as f32;
periods_per_dft_vec.push(periods_per_dft).unwrap();
info!("{}Hz: Sinus periods per DFT: {}", frequency, periods_per_dft);
// info!("{}Hz: Sinus periods per DFT: {}", frequency, periods_per_dft);
} else {
error!("DSP configuration not set, cannot calculate wait time");
return Err(ImpedanceInitError::DSPNotSet);
@@ -726,7 +725,7 @@ pub async fn impedance_setup_readout_task(mut pin: ExtiInput<'static>, impedance
let mut impedance_setup = impedance_setup.lock().await;
// Trigger the sequencer again
if impedance_setup.running_mode == RunningMode::SingleFrequency2Lead || impedance_setup.running_mode == RunningMode::SingleFrequency4Lead || impedance_setup.running_mode == RunningMode::MultiFrequency2Lead(MeasurementPointSet::Eight) || impedance_setup.running_mode == RunningMode::MultiFrequency2Lead(MeasurementPointSet::Eighteen) || impedance_setup.running_mode == RunningMode::MultiFrequency4Lead(MeasurementPointSet::Eight) || impedance_setup.running_mode == RunningMode::MultiFrequency4Lead(MeasurementPointSet::Eighteen) {
if impedance_setup.running_mode == RunningMode::SingleFrequency2Lead || impedance_setup.running_mode == RunningMode::SingleFrequency4Lead || impedance_setup.running_mode == RunningMode::SweepFrequency2Lead(MeasurementPointSet::Eight) || impedance_setup.running_mode == RunningMode::SweepFrequency2Lead(MeasurementPointSet::Eighteen) || impedance_setup.running_mode == RunningMode::SweepFrequency4Lead(MeasurementPointSet::Eight) || impedance_setup.running_mode == RunningMode::SweepFrequency4Lead(MeasurementPointSet::Eighteen) {
impedance_setup.start_measurement().await;
}
@@ -780,7 +779,7 @@ pub async fn impedance_setup_readout_task(mut pin: ExtiInput<'static>, impedance
}
}
}
RunningMode::MultiFrequency2Lead(points) => {
RunningMode::SweepFrequency2Lead(points) => {
// Each frequency point produces 4 samples (DFT real/imag for Rcal and Rz)
let required_count = points.len() * 4;
@@ -791,7 +790,7 @@ pub async fn impedance_setup_readout_task(mut pin: ExtiInput<'static>, impedance
impedance_setup.read_fifo(data_slice).await.unwrap();
// Output structure
let mut impedance_output = MultiImpedanceOutput {
let mut impedance_output = SweepImpedanceOutput {
points,
magnitudes_8: Vec::new(),
phases_8: Vec::new(),
@@ -815,11 +814,11 @@ pub async fn impedance_setup_readout_task(mut pin: ExtiInput<'static>, impedance
}
}
IMPEDANCE_CHANNEL_MULTI.try_send(impedance_output).ok();
IMPEDANCE_CHANNEL_SWEEP.try_send(impedance_output).ok();
}
continue;
}
RunningMode::MultiFrequency4Lead(points) => {
RunningMode::SweepFrequency4Lead(points) => {
// Each frequency point produces 4 samples (DFT real/imag for Rcal and Rz)
let required_count = points.len() * 4;
@@ -830,7 +829,7 @@ pub async fn impedance_setup_readout_task(mut pin: ExtiInput<'static>, impedance
impedance_setup.read_fifo(data_slice).await.unwrap();
// Output structure
let mut impedance_output = MultiImpedanceOutput {
let mut impedance_output = SweepImpedanceOutput {
points,
magnitudes_8: Vec::new(),
phases_8: Vec::new(),
@@ -865,7 +864,7 @@ pub async fn impedance_setup_readout_task(mut pin: ExtiInput<'static>, impedance
}
}
IMPEDANCE_CHANNEL_MULTI.try_send(impedance_output).ok();
IMPEDANCE_CHANNEL_SWEEP.try_send(impedance_output).ok();
}
continue;