ADC DMA Circular Sanity Check

[jngls]

I've got circular ADC DMA working but I'm not sure I've implemented it in a smart way. Essentially I want to continually sample the analog inputs, which as far as I can tell means I need to restart the DMA process every time I've read the second half buffer. Is that correct? Or is there a way to tell it to automatically start writing into the first half without me needing to restart it?

I expected the circular buffer mode to automatically start writing into the first half whilst I'm reading the second half, otherwise I may as well just use the single buffer Transfer method. Any clarity on the matter would be appreciated.

This is my current code:

    // Using a long buffer just whilst I'm using rprintln in the loop to prevent overruns
    const BUF_SIZE: usize = 4096;
    static mut BUF: [[u16; BUF_SIZE]; 2] = [[0; BUF_SIZE]; 2];

    // Setup ADC and DMA
    let dma_ch1 = dp.DMA1.split().1;
    let adc1 = Adc::adc1(dp.ADC1, clocks);
    let pin_adc_0 = gpioa.pa0.into_analog(&mut gpioa.crl);
    let adc_dma = adc1.with_dma(pin_adc_0, dma_ch1);
    let mut circ_buffer = unsafe { adc_dma.circ_read(&mut BUF) };

    let mut count = 0;
    let mut read_half = Half::Second;
    loop {
        // Poll DMA and restart where necessary
        match circ_buffer.readable_half() {
            Ok(half) => {
                if read_half != half {
                    read_half = half;

                    let _buf_inner = circ_buffer.peek(|b, _| *b).unwrap();
                    // Code to read _buf_inner goes here...
                    
                    // Restart DMA
                    if half == Half::Second {
                        let (buf, adc_dma) = circ_buffer.stop();
                        circ_buffer = adc_dma.circ_read(buf);
                    }
                    count += 1;
                    rprintln!("Read {} buffers", count);
                }
            },
            // Restart DMA
            Err(_) => {
                rprintln!("Buffer overrun");
                let (buf_inner, adc_dma) = circ_buffer.stop();
                circ_buffer = adc_dma.circ_read(buf_inner);
            },
        }
    }```

[jngls]

I'm no longer using this implementation. Still curious about circular DMA though