examples/ads1256/src/bin/multiplex.rs

@@ -10,12 +10,12 @@ use {defmt_rtt as _, panic_probe as _};
 
 use {embassy_executor as executor, embassy_stm32 as stm32};
 
+use ads1256::standard::input::SingleEnded;
 use ads1256::{
     AdControl, Ads1256, AutoCal, BitOrder, BlockingDelay, Buffer, ClockOut, Config, DState,
     DataRate, DigitalIo, DigitalIoDirection, DigitalIoState, DioDirection, Gain, Multiplexer,
     MuxInput, OutputPin, Sdcs, SpiBus, Status, Wait,
 };
-use ads1256::standard::input::SingleEnded;
 use embassy_time::{Delay, Duration, Timer};
 use executor::Spawner;
 use stm32::dma::NoDma;
@@ -57,9 +57,9 @@ impl ads1256::BlockingDelay for Ads1256Delay {
 }
 
 struct Inputs {
+    ai0: StatefulPublisher<f32::ElectricPotential, NoopRawMutex, 10, 1>,
     ai1: StatefulPublisher<f32::ElectricPotential, NoopRawMutex, 10, 1>,
     ai2: StatefulPublisher<f32::ElectricPotential, NoopRawMutex, 10, 1>,
-    ai3: StatefulPublisher<f32::ElectricPotential, NoopRawMutex, 10, 1>,
 }
 
 // Inputs
@@ -98,8 +98,12 @@ async fn main(spawner: Spawner) {
     ));
 
     let ads_1256 = ADS_1256.init(Ads1256::new(Ads1256Delay, select_ads1256, ads1256_data_ready));
-
+    ads_1256.write_config(spi, AUTOCAL_CONF).unwrap();
     let inputs = &*ANALOG_INPUTS.init(Inputs {
+        ai0: StatefulPublisher::new(
+            Cell::new(f32::ElectricPotential::new::<volt>(f32::NAN)).into(),
+            PubSubChannel::new().into(),
+        ),
         ai1: StatefulPublisher::new(
             Cell::new(f32::ElectricPotential::new::<volt>(f32::NAN)).into(),
             PubSubChannel::new().into(),
@@ -108,10 +112,6 @@ async fn main(spawner: Spawner) {
             Cell::new(f32::ElectricPotential::new::<volt>(f32::NAN)).into(),
             PubSubChannel::new().into(),
         ),
-        ai3: StatefulPublisher::new(
-            Cell::new(f32::ElectricPotential::new::<volt>(f32::NAN)).into(),
-            PubSubChannel::new().into(),
-        ),
     });
 
     spawner.spawn(log_task(inputs)).unwrap();
@@ -126,7 +126,7 @@ async fn drive_inputs_task(
     spi: &'static mut Spi<'static, SPI3, NoDma, NoDma>,
     inputs: &'static Inputs,
 ) {
-    let Inputs { ai1, ai2, ai3 } = inputs;
+    let Inputs { ai0, ai1, ai2 } = inputs;
 
     loop {
         let mut accumulator = f32::ElectricPotential::new::<volt>(0.0);
@@ -136,7 +136,7 @@ async fn drive_inputs_task(
             .await
             .unwrap()
             .to_voltage(AUTOCAL_CONF.ad_control.gain());
-        ai1.update(voltage);
+        ai0.update(voltage);
         accumulator += voltage;
 
         let voltage = ads_1256
@@ -144,7 +144,7 @@ async fn drive_inputs_task(
             .await
             .unwrap()
             .to_voltage(AUTOCAL_CONF.ad_control.gain());
-        ai2.update(voltage);
+        ai1.update(voltage);
         accumulator += voltage;
 
         let voltage = ads_1256
@@ -152,7 +152,7 @@ async fn drive_inputs_task(
             .await
             .unwrap()
             .to_voltage(AUTOCAL_CONF.ad_control.gain());
-        ai3.update(voltage);
+        ai2.update(voltage);
         accumulator += voltage;
 
         let accum_volts = accumulator.get::<volt>();
@@ -162,19 +162,19 @@ async fn drive_inputs_task(
 
 #[embassy_executor::task]
 async fn log_task(inputs: &'static Inputs) {
-    let Inputs { ai1, ai2, ai3 } = inputs;
+    let Inputs { ai0, ai1, ai2 } = inputs;
+    let mut ai0_sub = ai0.subscribe().unwrap();
     let mut ai1_sub = ai1.subscribe().unwrap();
     let mut ai2_sub = ai2.subscribe().unwrap();
-    let mut ai3_sub = ai3.subscribe().unwrap();
 
     loop {
+        let msg = ai0_sub.next_message_pure().await.get::<volt>();
+        info!("Log task ai0: {}", msg);
+
         let msg = ai1_sub.next_message_pure().await.get::<volt>();
         info!("Log task ai1: {}", msg);
 
         let msg = ai2_sub.next_message_pure().await.get::<volt>();
         info!("Log task ai2: {}", msg);
-
-        let msg = ai3_sub.next_message_pure().await.get::<volt>();
-        info!("Log task ai3: {}", msg);
     }
 }

examples/ads1256/src/bin/poll.rs

@@ -3,6 +3,7 @@
 #![feature(type_alias_impl_trait, async_fn_in_trait)]
 
 use core::cell::Cell;
+use core::ops::DerefMut;
 use cortex_m::prelude::{
     _embedded_hal_blocking_delay_DelayMs, _embedded_hal_blocking_delay_DelayUs,
 };
@@ -37,8 +38,8 @@ use embassy_sync::pubsub::PubSubChannel;
 use physical_ads1256::standard::multiplexer::poll::{
     AutocalPoll, AutocalPollStatePub, ModInputOnly,
 };
-use physical_node::transducer::{Publish, Publisher, StatefulPublisher};
 use physical_node::transducer::input::Poll;
+use physical_node::transducer::{Publish, Publisher, StatefulPublisher};
 
 const AUTOCAL_CONF: Config = Config {
     status: Status::setting(Buffer::Enabled, AutoCal::Enabled, BitOrder::MostSigFirst),
@@ -106,7 +107,7 @@ async fn main(spawner: Spawner) {
     let ads1256_data_ready = ExtiInput::new(Input::new(p.PF6, Pull::Up), p.EXTI6);
     let select_ads1256 = Output::new(p.PF7, Level::High, Speed::VeryHigh);
 
-    let spi = &*SPI.init(Mutex::new(Spi::new(
+    let spi = SPI.init(Mutex::new(Spi::new(
         p.SPI3,
         p.PC10,
         p.PC12,
@@ -118,7 +119,11 @@ async fn main(spawner: Spawner) {
     )));
 
     let ads_1256 =
-        &*ADS_1256.init(Mutex::new(Ads1256::new(Ads1256Delay, select_ads1256, ads1256_data_ready)));
+        ADS_1256.init(Mutex::new(Ads1256::new(Ads1256Delay, select_ads1256, ads1256_data_ready)));
+    ads_1256
+        .get_mut()
+        .write_config(spi.get_mut(), AUTOCAL_CONF)
+        .unwrap();
 
     let inputs = &*ANALOG_INPUTS.init(Inputs {
         ai1: AutocalPollStatePub {
@@ -161,13 +166,19 @@ async fn main(spawner: Spawner) {
     spawner.spawn(log_task(&inputs.ai1, 1)).unwrap();
     spawner.spawn(log_task(&inputs.ai2, 2)).unwrap();
     spawner.spawn(log_task(&inputs.ai3, 3)).unwrap();
-    spawner.spawn(poll_task(&inputs.ai1, 1, Duration::from_secs(5))).unwrap();
+    spawner
-    spawner.spawn(poll_task(&inputs.ai2, 2, Duration::from_secs(10))).unwrap();
+        .spawn(poll_task(&inputs.ai1, 1, Duration::from_secs(5)))
-    spawner.spawn(poll_task(&inputs.ai3, 3, Duration::from_secs(20))).unwrap();
+        .unwrap();
+    spawner
+        .spawn(poll_task(&inputs.ai2, 2, Duration::from_secs(10)))
+        .unwrap();
+    spawner
+        .spawn(poll_task(&inputs.ai3, 3, Duration::from_secs(20)))
+        .unwrap();
 }
 
 #[embassy_executor::task(pool_size = 3)]
-async fn poll_task(input: &'static ExampleInput, input_num: u8, every: Duration,) {
+async fn poll_task(input: &'static ExampleInput, input_num: u8, every: Duration) {
     loop {
         Timer::after(every).await;
         let result = input.poll().await.unwrap().get::<volt>();