test: update hil test for i2s move api

Author: AstrickHarren

hil-test/tests/i2s.rs

@@ -13,6 +13,7 @@
 use esp_hal::{
     Async,
     delay::Delay,
+    dma::{DmaDescriptor, DmaTxStreamBuf},
     dma_buffers,
     gpio::{AnyPin, NoPin, Pin},
     i2s::master::{DataFormat, I2s, I2sTx, Standard},
@@ -59,24 +60,28 @@ impl Iterator for SampleSource {
 }
 
 #[embassy_executor::task]
-async fn writer(tx_buffer: &'static mut [u8], i2s_tx: I2sTx<'static, Async>) {
+async fn writer(
+    tx_buffer: &'static mut [u8],
+    tx_descriptors: &'static mut [DmaDescriptor],
+    i2s_tx: I2sTx<'static, Async>,
+) {
     let mut samples = SampleSource::new();
     for b in tx_buffer.iter_mut() {
         *b = samples.next().unwrap();
     }
 
-    let mut tx_transfer = i2s_tx.write_dma_circular_async(tx_buffer).unwrap();
+    let mut tx_transfer = i2s_tx
+        .write(DmaTxStreamBuf::new(tx_descriptors, tx_buffer).unwrap())
+        .unwrap();
 
     loop {
-        tx_transfer
-            .push_with(|buffer| {
-                for b in buffer.iter_mut() {
-                    *b = samples.next().unwrap();
-                }
-                buffer.len()
-            })
-            .await
-            .unwrap();
+        tx_transfer.wait_for_available().await.unwrap();
+        tx_transfer.push_with(|buffer| {
+            for b in buffer.iter_mut() {
+                *b = samples.next().unwrap();
+            }
+            buffer.len()
+        });
     }
 }
 
@@ -99,6 +104,8 @@ fn enable_loopback() {
 #[cfg(test)]
 #[embedded_test::tests(default_timeout = 3, executor = hil_test::Executor::new())]
 mod tests {
+    use esp_hal::dma::DmaRxStreamBuf;
+
     use super::*;
 
     struct Context {
@@ -153,26 +160,33 @@ mod tests {
             .with_bclk(NoPin)
             .with_ws(NoPin)
             .with_dout(dout)
-            .build(tx_descriptors);
+            .build();
 
         let i2s_rx = i2s
             .i2s_rx
             .with_bclk(NoPin)
             .with_ws(NoPin)
             .with_din(din)
-            .build(rx_descriptors);
+            .build();
 
         enable_loopback();
 
-        let mut rx_transfer = i2s_rx.read_dma_circular_async(rx_buffer).unwrap();
-        spawner.must_spawn(writer(tx_buffer, i2s_tx));
+        let mut rx_transfer = i2s_rx
+            .read(
+                DmaRxStreamBuf::new(rx_descriptors, rx_buffer).unwrap(),
+                BUFFER_SIZE,
+            )
+            .unwrap();
+        spawner.must_spawn(writer(tx_buffer, tx_descriptors, i2s_tx));
 
-        let mut rcv = [0u8; BUFFER_SIZE];
+        // let mut rcv = [0u8; BUFFER_SIZE];
         let mut sample_idx = 0;
         let mut samples = SampleSource::new();
         for _ in 0..30 {
-            let len = rx_transfer.pop(&mut rcv).await.unwrap();
-            for &b in &rcv[..len] {
+            rx_transfer.wait_for_available().await.unwrap();
+            let data = rx_transfer.peek();
+            let len = data.len();
+            for &b in data {
                 let expected = samples.next().unwrap();
                 assert_eq!(
                     b, expected,
@@ -181,6 +195,7 @@ mod tests {
                 );
                 sample_idx += 1;
             }
+            rx_transfer.consume(len);
         }
     }
 
@@ -198,19 +213,19 @@ mod tests {
 
         let (din, dout) = unsafe { ctx.dout.split() };
 
-        let mut i2s_tx = i2s
+        let i2s_tx = i2s
             .i2s_tx
             .with_bclk(NoPin)
             .with_ws(NoPin)
             .with_dout(dout)
-            .build(tx_descriptors);
+            .build();
 
-        let mut i2s_rx = i2s
+        let i2s_rx = i2s
             .i2s_rx
             .with_bclk(NoPin)
             .with_ws(NoPin)
             .with_din(din)
-            .build(rx_descriptors);
+            .build();
 
         enable_loopback();
 
@@ -222,51 +237,53 @@ mod tests {
         let mut rcv = [0u8; 11000];
         let mut filler = [0x1u8; 12000];
 
-        let mut rx_transfer = i2s_rx.read_dma_circular(rx_buffer).unwrap();
-        // trying to pop data before calling `available` should just do nothing
-        assert_eq!(0, rx_transfer.pop(&mut rcv[..100]).unwrap());
+        let mut rx_transfer = i2s_rx
+            .read(
+                DmaRxStreamBuf::new(rx_descriptors, rx_buffer).unwrap(),
+                4000,
+            )
+            .unwrap();
+        // trying to peek data before calling `available` should just do nothing
+        assert_eq!(0, rx_transfer.peek().len());
 
         // no data available yet
-        assert_eq!(0, rx_transfer.available().unwrap());
+        assert_eq!(0, rx_transfer.available_bytes());
 
-        let mut tx_transfer = i2s_tx.write_dma_circular(tx_buffer).unwrap();
+        let mut tx_transfer = i2s_tx
+            .write(DmaTxStreamBuf::new(tx_descriptors, tx_buffer).unwrap())
+            .unwrap();
 
         let mut iteration = 0;
         let mut sample_idx = 0;
         let mut check_samples = SampleSource::new();
         loop {
-            let tx_avail = tx_transfer.available().unwrap();
+            let tx_avail = tx_transfer.available_bytes();
 
             // make sure there are more than one descriptor buffers ready to push
             if tx_avail > 5000 {
                 for b in &mut filler[0..tx_avail].iter_mut() {
                     *b = samples.next().unwrap();
                 }
-                tx_transfer.push(&filler[0..tx_avail]).unwrap();
+                tx_transfer.push(&filler[0..tx_avail]);
             }
 
             // test calling available multiple times doesn't break anything
-            rx_transfer.available().unwrap();
-            rx_transfer.available().unwrap();
-            rx_transfer.available().unwrap();
-            rx_transfer.available().unwrap();
-            rx_transfer.available().unwrap();
-            rx_transfer.available().unwrap();
-            let rx_avail = rx_transfer.available().unwrap();
+            rx_transfer.available_bytes();
+            rx_transfer.available_bytes();
+            rx_transfer.available_bytes();
+            rx_transfer.available_bytes();
+            rx_transfer.available_bytes();
+            rx_transfer.available_bytes();
+            let rx_avail = rx_transfer.available_bytes();
 
             // make sure there are more than one descriptor buffers ready to pop
             if rx_avail > 0 {
-                // trying to pop less data than available is an error
-                assert_eq!(
-                    Err(esp_hal::dma::DmaError::BufferTooSmall),
-                    rx_transfer.pop(&mut rcv[..rx_avail / 2])
-                );
-
                 rcv.fill(0xff);
-                let len = rx_transfer.pop(&mut rcv).unwrap();
+                let data = rx_transfer.peek();
+                let len = data.len();
                 assert!(len > 0);
 
-                for &b in &rcv[..len] {
+                for &b in data {
                     let expected = check_samples.next().unwrap();
                     assert_eq!(
                         b, expected,
@@ -276,6 +293,8 @@ mod tests {
                     sample_idx += 1;
                 }
 
+                rx_transfer.consume(len);
+
                 iteration += 1;
 
                 if iteration == 1 {
@@ -290,60 +309,4 @@ mod tests {
             }
         }
     }
-
-    #[test]
-    fn test_i2s_push_too_late(ctx: Context) {
-        let (_, _, tx_buffer, tx_descriptors) = dma_buffers!(0, 16000);
-
-        let i2s = I2s::new(
-            ctx.i2s,
-            Standard::Philips,
-            DataFormat::Data16Channel16,
-            Rate::from_hz(16000),
-            ctx.dma_channel,
-        );
-
-        let mut i2s_tx = i2s
-            .i2s_tx
-            .with_bclk(NoPin)
-            .with_ws(NoPin)
-            .with_dout(ctx.dout)
-            .build(tx_descriptors);
-
-        let mut tx_transfer = i2s_tx.write_dma_circular(tx_buffer).unwrap();
-
-        let delay = esp_hal::delay::Delay::new();
-        delay.delay_millis(300);
-
-        assert!(matches!(tx_transfer.push(&[0; 128]), Err(_)));
-    }
-
-    #[test]
-    #[timeout(1)]
-    fn test_i2s_read_too_late(ctx: Context) {
-        let (rx_buffer, rx_descriptors, _, _) = dma_buffers!(16000, 0);
-
-        let i2s = I2s::new(
-            ctx.i2s,
-            Standard::Philips,
-            DataFormat::Data16Channel16,
-            Rate::from_hz(16000),
-            ctx.dma_channel,
-        );
-
-        let mut i2s_rx = i2s
-            .i2s_rx
-            .with_bclk(NoPin)
-            .with_ws(NoPin)
-            .with_din(ctx.dout) // not a typo
-            .build(rx_descriptors);
-
-        let mut buffer = [0u8; 1024];
-        let mut rx_transfer = i2s_rx.read_dma_circular(rx_buffer).unwrap();
-
-        let delay = esp_hal::delay::Delay::new();
-        delay.delay_millis(300);
-
-        assert!(matches!(rx_transfer.pop(&mut buffer), Err(_)));
-    }
 }