The ADC does not work in continuous mode if there is a small delay after starting

[faunel]

The ADC does not work in continuous mode if there is a small delay after starting (transfer.start)
A delay of 1 ms is sufficient (line delay.delay_ms(1);).

I tested this on two boards - STM32F401CE, STM32F411CE (Black pill)
And the issue occurs on both.

Also, the ADC can suddenly stop working if there is a blocking operation in the task for a few milliseconds during the process.
There are no errors in this case.

Also, in single mode, if we start the ADC in the interrupt handler,
the ADC can also suddenly stop working.
This manifests at a start frequency of 100 kHz, Pclk2_div_2, and a small number of cycles (Cycles_112 or less).

#[init]
    fn init(cx: init::Context) -> (Shared, Local) {
        let dp = cx.device;
        let cp = cx.core;

        // Clock configuration
        let clocks = dp
            .RCC
            .constrain()
            .cfgr
            .use_hse(25.MHz())
            .sysclk(80.MHz())
            .freeze();

        // GPIO
        let gpioa = dp.GPIOA.split();

        let mut delay = cp.SYST.delay(&clocks);

        // ADC pin configuration
        let adc_pin1 = gpioa.pa1.into_analog();
        let adc_pin2 = gpioa.pa2.into_analog();

        // DMA stream
        let dma = StreamsTuple::new(dp.DMA2);

        // ADC config
        let adc_config = AdcConfig::default()
            .dma(Dma::Continuous)
            .scan(Scan::Enabled)
            .clock(Clock::Pclk2_div_8)
            .continuous(Continuous::Continuous);

        // ADC channel configuration
        let mut adc = Adc::adc1(dp.ADC1, true, adc_config);
        adc.configure_channel(&adc_pin1, Sequence::One, SampleTime::Cycles_480);
        adc.configure_channel(&adc_pin2, Sequence::Two, SampleTime::Cycles_480);
 
        let first_buffer = cortex_m::singleton!(: [u16; 2] = [0; 2]).unwrap();
        let buffer = Some(cortex_m::singleton!(: [u16; 2] = [0; 2]).unwrap());

        // DMA config
        let dma_config = DmaConfig::default()
            .transfer_complete_interrupt(true)
            .memory_increment(true)
            .double_buffer(false);

        let mut transfer =
            Transfer::init_peripheral_to_memory(dma.0, adc, first_buffer, None, dma_config);

        transfer.start(|adc| {
            adc.start_conversion();
        });

        // It does not work with this delay.
        delay.delay_ms(1);

        (
            Shared {
                transfer
            },
            Local {
                buffer
            },
        )
    }

Added a project with an example in the attachment.
adc_bug.zip