Atmel SAM D21 DMA завис в состоянии занятости при использовании USB

Я использую SAMD21 xPlained pro с прототипом для получения сигнала, используя внутренний АЦП и DMAC, которые настроены на сбор 5500 выборок. Затем образцы передаются в приложение для ПК через целевой USB.

Прошивка, которую я написал для этого, работает, но я заметил, что время от времени DMA зависает в состоянии занятости. Чтобы отладить это, я отменил передачу части на ПК через USB.

Я заметил, что DMA работает нормально и передает сэмплы в память, но если я подключаю кабель USB к ПК (без передачи данных через USB), время от времени DMA зависает; но как только я отсоединяю (целевой) USB-кабель, DMA работает непрерывно, не застревая в состоянии занятости.

Я подозреваю, что это что-то с прерыванием и приоритетами USB и АЦП, которые используют DMA. Я подумал, что должен установить выборку АЦП с наивысшим приоритетом, чтобы USB не приводил к зависанию DMA в состоянии занятости, но я не смог найти, как это настроить в коде (я использую ASF).

Любая идея, почему подключение USB приводит к тому, что DMA иногда зависает в состоянии занятости? Должна ли эта проблема относиться к приоритетам, как я подозреваю, есть идеи, как уменьшить приоритет прерывания USB?

код:

void GSWatchMainProcess(void)
{
    static int i=0;

    GSPacket PacketToStream;

    switch (KnockKnockStateMachine)
    {
        case InitKnockKnock:
            KnockKnockStateMachine = KnockKnockStandby;
            break;

        case KnockKnockStandby:
            if (StreamADC && !RequestForAcknowledge) KnockKnockStateMachine = WakeupAphrodite;
            KnockKnockStateMachine = WakeupAphrodite;       //this line was added to skip waiting for a command from the PC
            break;

        case WakeupAphrodite:
            if (dma_is_busy(&example_resource))
            {
                KnockKnockStateMachine = AbortKnockKnock;
            }
            else
            {
                port_pin_set_output_level(PIN_PB09, true);
                port_pin_set_output_level(LED_0_PIN, false);
                transfer_is_done = false;
                if(dma_start_transfer_job(&example_resource))
                {
                    KnockKnockStateMachine = AbortKnockKnock;
                }
            }

            KnockKnockStateMachine = WaitForBurstToEnd;
            i=200000;       //this counter is used as work-around to reset the DMA when it get stuck after timeout
            break;

        case WaitForBurstToEnd:
            if (!dma_is_busy(&example_resource))
            {
                KnockKnockStateMachine = ProcessBurst;
            }
            if(!--i)        // work-around to reset DMA when it get stuck
            {
                KnockKnockStateMachine = AbortKnockKnock;
            }
            break;

        case ProcessBurst:
            PacketToStream.Type=Stream;
            PacketToStream.ContentLength=0;
            for (i = 0; i<(ADC_SAMPLES); i++)
            {
                PacketToStream.Content[PacketToStream.ContentLength++] = adc_result_buffer[i] / 256;
                PacketToStream.Content[PacketToStream.ContentLength++] = adc_result_buffer[i] % 256;
                if(PacketToStream.ContentLength>=PACKET_MAX_SIZE)
                {
                    //SendViaGSWatchLink(PacketToStream);
                    PacketToStream.ContentLength=0;
                }
            }
            //if(PacketToStream.ContentLength>0) SendViaGSWatchLink(PacketToStream);
            RequestForAcknowledge = true;
            KnockKnockStateMachine = KnockKnockStandby;
            break;

        case AbortKnockKnock:
            dma_abort_job(&example_resource);
            dma_free(&example_resource);
            port_pin_set_output_level(PIN_PB09, false);
            port_pin_set_output_level(LED_0_PIN, true);
            transfer_is_done = true;

            configure_dma_resource(&example_resource);
            setup_transfer_descriptor(&DMA_ADC_descriptor);
            dma_add_descriptor(&example_resource, &DMA_ADC_descriptor);
            dma_register_callback(&example_resource, transfer_done, DMA_CALLBACK_TRANSFER_DONE);
            dma_enable_callback(&example_resource, DMA_CALLBACK_TRANSFER_DONE);
            system_interrupt_enable_global();

            KnockKnockStateMachine = WakeupAphrodite;
            break;
    }
}




void transfer_done(struct dma_resource* const resource )
{
    transfer_is_done = true;
    port_pin_set_output_level(PIN_PB09, false);
    port_pin_set_output_level(LED_0_PIN, true);

}
void setup_transfer_descriptor(DmacDescriptor *descriptor)
{
    struct dma_descriptor_config descriptor_config;
    dma_descriptor_get_config_defaults(&descriptor_config);
    descriptor_config.beat_size = DMA_BEAT_SIZE_HWORD;
    descriptor_config.block_transfer_count = ADC_SAMPLES;
    descriptor_config.dst_increment_enable = true;
    descriptor_config.src_increment_enable = false;
    descriptor_config.source_address = (uint32_t)(&adc_instance.hw->RESULT.reg);
    //descriptor_config.destination_address = (uint32_t)adc_result_buffer + 2 * ADC_SAMPLES;
    descriptor_config.destination_address = (uint32_t)adc_result_buffer + sizeof(adc_result_buffer);
    dma_descriptor_create(descriptor, &descriptor_config);
}
void configure_dma_resource(struct dma_resource *resource)
{
    struct dma_resource_config config_dma;
    dma_get_config_defaults(&config_dma);
    config_dma.peripheral_trigger = ADC_DMAC_ID_RESRDY;
    config_dma.trigger_action = DMA_TRIGGER_ACTON_BEAT;
    config_dma.priority = DMA_PRIORITY_LEVEL_3;
    dma_allocate(resource, &config_dma);
}
void configure_adc(void)
{
    struct adc_config config_adc;
    adc_get_config_defaults(&config_adc);
    //  config_adc.gain_factor          = ADC_GAIN_FACTOR_DIV2;  //TODO: check if we need this feature
    config_adc.clock_prescaler      = ADC_CLOCK_PRESCALER_DIV32; //TODO: check whether it possible to work with 8
    config_adc.reference            = ADC_REFERENCE_INTVCC0; //ADC_REFERENCE_INT1V; //ADC_REFERENCE_INTVCC1;
    config_adc.positive_input       = ADC_POSITIVE_INPUT_PIN8;
    config_adc.negative_input       = ADC_NEGATIVE_INPUT_GND;
    config_adc.resolution           = ADC_RESOLUTION_12BIT;
    config_adc.sample_length        = 0;    //4
    config_adc.differential_mode    = false;
    config_adc.freerunning          = true;

    adc_init(&adc_instance, ADC, &config_adc);
    adc_enable(&adc_instance);
}