rp: Add multichannel ADC

1 files changed, 66 insertions, 5 deletions

diff --git a/embassy-rp/src/adc.rs b/embassy-rp/src/adc.rs
index 101c5b71f..be453d08e 100644
--- a/embassy-rp/src/adc.rs
+++ b/embassy-rp/src/adc.rs
@@ -221,16 +221,26 @@ impl<'d> Adc<'d, Async> {
 
     async fn read_many_inner<W: dma::Word>(
         &mut self,
-        ch: &mut Channel<'_>,
+        channels: impl Iterator<Item = u8>,
         buf: &mut [W],
         fcs_err: bool,
         div: u16,
         dma: impl Peripheral<P = impl dma::Channel>,
     ) -> Result<(), Error> {
+        let mut rrobin = 0_u8;
+        for c in channels {
+            rrobin |= 1 << c;
+        }
+        let first_ch = rrobin.trailing_zeros() as u8;
+        if rrobin.count_ones() == 1 {
+            rrobin = 0;
+        }
+
         let r = Self::regs();
         // clear previous errors and set channel
         r.cs().modify(|w| {
-            w.set_ainsel(ch.channel());
+            w.set_ainsel(first_ch);
+            w.set_rrobin(rrobin);
             w.set_err_sticky(true); // clear previous errors
             w.set_start_many(false);
         });
@@ -283,7 +293,49 @@ impl<'d> Adc<'d, Async> {
         }
     }
 
+    /// Sample multiple values from multiple channels using DMA.
+    /// Samples are stored in an interleaved fashion inside the buffer.
+    /// `div` is the integer part of the clock divider and can be calculated with `floor(48MHz / sample_rate * num_channels - 1)`
+    /// Any `div` value of less than 96 will have the same effect as setting it to 0
+    #[inline]
+    pub async fn read_many_multichannel<S: AdcSample>(
+        &mut self,
+        ch: &mut [Channel<'_>],
+        buf: &mut [S],
+        div: u16,
+        dma: impl Peripheral<P = impl dma::Channel>,
+    ) -> Result<(), Error> {
+        self.read_many_inner(ch.iter().map(|c| c.channel()), buf, false, div, dma)
+            .await
+    }
+
+    /// Sample multiple values from multiple channels using DMA, with errors inlined in samples.
+    /// Samples are stored in an interleaved fashion inside the buffer.
+    /// `div` is the integer part of the clock divider and can be calculated with `floor(48MHz / sample_rate * num_channels - 1)`
+    /// Any `div` value of less than 96 will have the same effect as setting it to 0
+    #[inline]
+    pub async fn read_many_multichannel_raw(
+        &mut self,
+        ch: &mut [Channel<'_>],
+        buf: &mut [Sample],
+        div: u16,
+        dma: impl Peripheral<P = impl dma::Channel>,
+    ) {
+        // errors are reported in individual samples
+        let _ = self
+            .read_many_inner(
+                ch.iter().map(|c| c.channel()),
+                unsafe { mem::transmute::<_, &mut [u16]>(buf) },
+                true,
+                div,
+                dma,
+            )
+            .await;
+    }
+
     /// Sample multiple values from a channel using DMA.
+    /// `div` is the integer part of the clock divider and can be calculated with `floor(48MHz / sample_rate - 1)`
+    /// Any `div` value of less than 96 will have the same effect as setting it to 0
     #[inline]
     pub async fn read_many<S: AdcSample>(
         &mut self,
@@ -292,10 +344,13 @@ impl<'d> Adc<'d, Async> {
         div: u16,
         dma: impl Peripheral<P = impl dma::Channel>,
     ) -> Result<(), Error> {
-        self.read_many_inner(ch, buf, false, div, dma).await
+        self.read_many_inner([ch.channel()].into_iter(), buf, false, div, dma)
+            .await
     }
 
-    /// Sample multiple values from a channel using DMA with errors inlined in samples.
+    /// Sample multiple values from a channel using DMA, with errors inlined in samples.
+    /// `div` is the integer part of the clock divider and can be calculated with `floor(48MHz / sample_rate - 1)`
+    /// Any `div` value of less than 96 will have the same effect as setting it to 0
     #[inline]
     pub async fn read_many_raw(
         &mut self,
@@ -306,7 +361,13 @@ impl<'d> Adc<'d, Async> {
     ) {
         // errors are reported in individual samples
         let _ = self
-            .read_many_inner(ch, unsafe { mem::transmute::<_, &mut [u16]>(buf) }, true, div, dma)
+            .read_many_inner(
+                [ch.channel()].into_iter(),
+                unsafe { mem::transmute::<_, &mut [u16]>(buf) },
+                true,
+                div,
+                dma,
+            )
             .await;
     }
 }