Merge #425

425: Implements continuous sampling for the nRF SAADC r=huntc a=huntc

Implements continuous sampling for the nRF SAADC and also renames `OneShot` to `Saadc`. The one-shot behaviour is retained with the `sample` method and a new `run_sampler` method is provided for efficiently (i.e. zero copying) sampler processing. A double buffer is used for continuously sampling, which is swapped appropriately.

A sample frequency is provided and will set the internal timer of the SAADC when there is just one channel being sampled. Otherwise, PPI will be used to hook up the TIMER peripheral to drive the sampling task. Two methods are provided for this: `run_task_sampler` and `run_task_sampler` with the latter available where the compiler sees that just one channel is configured. Note that we set up the PPI and timer behaviour outside of the `Saadc` for maximum flexibility.

A callback is provided to the `run_sampler` method. This is a synchronous callback that should return in a reasonably short space of time. The SAADC could stall if it does not. A reasonable practice is to perform a small amount of processing within the callback to yield a signal, perhaps via `mpsc`. In the case of `mpsc`, the `try_send` method becomes useful.

A new example has been provided to illustrate continuous sampling, along with multiple channels and external timing:

```rust
#[embassy::main]
async fn main(_spawner: Spawner, mut p: Peripherals) {
    let config = Config::default();
    let channel_1_config = ChannelConfig::single_ended(&mut p.P0_02);
    let channel_2_config = ChannelConfig::single_ended(&mut p.P0_03);
    let channel_3_config = ChannelConfig::single_ended(&mut p.P0_04);
    let mut saadc = Saadc::new(
        p.SAADC,
        interrupt::take!(SAADC),
        config,
        [channel_1_config, channel_2_config, channel_3_config],
    );

    let mut timer = Timer::new(p.TIMER0);
    timer.set_frequency(Frequency::F1MHz);
    timer.cc(0).write(100); // We want to sample at 10KHz
    timer.cc(0).short_compare_clear();

    let mut ppi = Ppi::new(p.PPI_CH0);
    ppi.set_event(timer.cc(0).event_compare());
    ppi.set_task(saadc.task_sample());
    ppi.enable();

    timer.start();

    let mut bufs = [[[0; 3]; 50]; 2];

    let mut c = 0;
    let mut a: i32 = 0;

    saadc
        .run_task_sampler(&mut bufs, move |buf| {
            for b in buf {
                a += b[0] as i32;
            }
            c += buf.len();
            if c > 10000 {
                a = a / c as i32;
                info!("channel 1: {=i32}", a);
                c = 0;
                a = 0;
            }
            SamplerState::Sampled
        })
        .await;
}
```

Co-authored-by: huntc <huntchr@gmail.com>

examples/nrf/src/bin/saadc.rs

@@ -7,7 +7,7 @@ mod example_common;
 use defmt::panic;
 use embassy::executor::Spawner;
 use embassy::time::{Duration, Timer};
-use embassy_nrf::saadc::{ChannelConfig, Config, OneShot};
+use embassy_nrf::saadc::{ChannelConfig, Config, Saadc};
 use embassy_nrf::{interrupt, Peripherals};
 use example_common::*;
 
@@ -15,7 +15,7 @@ use example_common::*;
 async fn main(_spawner: Spawner, mut p: Peripherals) {
     let config = Config::default();
     let channel_config = ChannelConfig::single_ended(&mut p.P0_02);
-    let mut saadc = OneShot::new(p.SAADC, interrupt::take!(SAADC), config, [channel_config]);
+    let mut saadc = Saadc::new(p.SAADC, interrupt::take!(SAADC), config, [channel_config]);
 
     loop {
         let mut buf = [0; 1];

examples/nrf/src/bin/saadc_continuous.rs

@@ -0,0 +1,62 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+#[path = "../example_common.rs"]
+mod example_common;
+use defmt::panic;
+use embassy::executor::Spawner;
+use embassy_nrf::ppi::Ppi;
+use embassy_nrf::saadc::{ChannelConfig, Config, Saadc, SamplerState};
+use embassy_nrf::timer::{Frequency, Timer};
+use embassy_nrf::{interrupt, Peripherals};
+use example_common::*;
+
+// Demonstrates both continuous sampling and scanning multiple channels driven by a PPI linked timer
+
+#[embassy::main]
+async fn main(_spawner: Spawner, mut p: Peripherals) {
+    let config = Config::default();
+    let channel_1_config = ChannelConfig::single_ended(&mut p.P0_02);
+    let channel_2_config = ChannelConfig::single_ended(&mut p.P0_03);
+    let channel_3_config = ChannelConfig::single_ended(&mut p.P0_04);
+    let mut saadc = Saadc::new(
+        p.SAADC,
+        interrupt::take!(SAADC),
+        config,
+        [channel_1_config, channel_2_config, channel_3_config],
+    );
+
+    let mut timer = Timer::new(p.TIMER0);
+    timer.set_frequency(Frequency::F1MHz);
+    timer.cc(0).write(100); // We want to sample at 10KHz
+    timer.cc(0).short_compare_clear();
+
+    let mut ppi = Ppi::new(p.PPI_CH0);
+    ppi.set_event(timer.cc(0).event_compare());
+    ppi.set_task(saadc.task_sample());
+    ppi.enable();
+
+    timer.start();
+
+    let mut bufs = [[[0; 3]; 50]; 2];
+
+    let mut c = 0;
+    let mut a: i32 = 0;
+
+    saadc
+        .run_task_sampler(&mut bufs, move |buf| {
+            for b in buf {
+                a += b[0] as i32;
+            }
+            c += buf.len();
+            if c > 10000 {
+                a = a / c as i32;
+                info!("channel 1: {=i32}", a);
+                c = 0;
+                a = 0;
+            }
+            SamplerState::Sampled
+        })
+        .await;
+}