STM32 zwei DMA-Streams mit gleicher Triggerquelle

[Paul S. (mrpaul)]

Hallo,

ich möchte in meiner Anwendung die Ergebnisse einer ADC-Messung 
GLEICHZEITIG in zwei Puffer (bufA, bufB) schreiben.
Beim ADC nutze ich den "Dual Regular Simultaneous"-Mode, d.h. ADC1 & 
ADC2 werden zeitgleich getriggert. Das Ergebnis (2x16Bit) soll dann 
parallel in die beiden Puffer geschrieben werden. Das Schreiben in den 
Puffer A funktioniert, nur im Puffer B kommt nichts an.
Zur Überprüfung habe ich die "DMA-HalfTransfer"-Interrupts genutzt, um 
mir den Inhalt der Puffer auszugeben. Der Interrupt für den DMA-Stream, 
der Puffer A füttert, wird generiert, der für den anderen Stream/Puffer 
hingegen nicht.
Aktiviere ich jedoch nur den Zweiten und lasse den Stream für den ersten 
Puffer deaktiviert, wird der zweite Puffer ordnungsgemäß gefüllt.
Bei den Streams handelt es sich um DMA2_Stream0 und DMA2_Stream4, 
jeweils mit Channel 0 (=ADC1).

Nun meine Frage:
Kann es sein, dass eine Quelle (ADC1) nicht mehrere DMA-Streams 
gleichzeitig triggern kann? Ich habe nicht wirklich einen Hinweis 
gefunden, dass man das nicht darf.
Aber sobald ich beide Streams nutze, gewinnt DMA2_Stream0.
Scheinbar setzt die Ausführung des DMA2_Stream0 den Trigger zurück, 
sodass bei DMA2_Stream4 nichts mehr ankommt. Ist dem so?

Gäbe es eine Alternative zu meinem Ansatz?

Eine Idee wäre noch, dass der Transfer des ersten Streams den zweiten 
triggert und so die Daten von Puffer A nach B kopiert anstatt diese 
direkt vom ADC zu lesen. Wäre das möglich?

Hier mein Programmcode:

void ADCInit(){
  GPIO_InitTypeDef GPIO_InitStructure;
  ADC_CommonInitTypeDef ADC_CommonInitStructure;
  ADC_InitTypeDef ADC_InitStructure;
  DMA_InitTypeDef DMA_InitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;

  adcBuffer.bufFFT=0;  // no buffer assigned -> no execution
  for(int i=0;i<ADC_BUFFER_LENGTH;i++){
    adcBuffer.bufA[i]=0;
    adcBuffer.bufB[i]=0;
  }
  adcBuffer.streamAEnabled = FALSE;
  adcBuffer.streamBEnabled = FALSE;

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC2, ENABLE);

  // initialize I/O's
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  // initialize common ADC
  ADC_CommonInitStructure.ADC_Mode = ADC_DualMode_RegSimult;
  ADC_CommonInitStructure.ADC_Prescaler = ADC_Prescaler_Div4;
  ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_1;
  ADC_CommonInitStructure.ADC_TwoSamplingDelay = ADC_TwoSamplingDelay_5Cycles;
  ADC_CommonInit(&ADC_CommonInitStructure);

  // initialize ADC1 & ADC2
  ADC_InitStructure.ADC_Resolution = ADC_Resolution_10b;
  ADC_InitStructure.ADC_ScanConvMode = DISABLE;
  ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
  ADC_InitStructure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_Rising;
  ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T2_TRGO;
  ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
  ADC_InitStructure.ADC_NbrOfConversion = 1;
  ADC_Init(ADC1, &ADC_InitStructure);
  ADC_Init(ADC2, &ADC_InitStructure);

  // ADC1 & ADC2 regular channel configuration
  // ADC1: CH0 at pin A0
  // ADC2: CH1 at pin A1
  ADC_RegularChannelConfig(ADC1, ADC_Channel_0, 1, ADC_SampleTime_3Cycles);
  ADC_RegularChannelConfig(ADC2, ADC_Channel_1, 1, ADC_SampleTime_3Cycles);

  // enable DMA request after last transfer
  ADC_MultiModeDMARequestAfterLastTransferCmd(ENABLE);

  // initialize DMA streams
  // both streams are filling the buffers circular
  // the half transfer interrupt is used to switch the pointers
  // second DMA stream starts, when first stream has filled half buffer
  DMA_Cmd(DMA2_Stream0, DISABLE);
  DMA_Cmd(DMA2_Stream4, DISABLE);
  DMA_DeInit(DMA2_Stream0);
  DMA_DeInit(DMA2_Stream4);
    DMA_InitStructure.DMA_Channel = DMA_Channel_0;
    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&ADC->CDR;
    DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)(&adcBuffer.bufA);
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
    DMA_InitStructure.DMA_BufferSize = ADC_BUFFER_LENGTH;
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord; // 16 bit
    DMA_InitStructure.DMA_MemoryDataSize = DMA_PeripheralDataSize_HalfWord;    // 16bit per Transfer
    DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
    DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
    DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable;
    DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_1QuarterFull;  // may replace by FULL
    DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
    DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
    DMA_Init(DMA2_Stream0, &DMA_InitStructure);
    DMA_InitStructure.DMA_Channel = DMA_Channel_0;
    DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)(&adcBuffer.bufB);
    DMA_Init(DMA2_Stream4, &DMA_InitStructure);

    // configure DMA half transfer complete interrupt
  NVIC_InitStructure.NVIC_IRQChannel = DMA2_Stream0_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = NVIC_PRIORITY_DMA2_STREAM0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = NVIC_SUBPRIORITY_DMA2_STREAM0;
  NVIC_Init(&NVIC_InitStructure);

  NVIC_InitStructure.NVIC_IRQChannel = DMA2_Stream4_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = NVIC_PRIORITY_DMA2_STREAM4;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = NVIC_SUBPRIORITY_DMA2_STREAM4;
  NVIC_Init(&NVIC_InitStructure);

  // enable DMA half transfer complete interrupt
  DMA_ITConfig(DMA2_Stream0, DMA_IT_HT, ENABLE);
  DMA_ITConfig(DMA2_Stream4, DMA_IT_HT, ENABLE);

  // enable DMA streams
  adcBuffer.streamAEnabled = TRUE;
  DMA_Cmd(DMA2_Stream0, ENABLE);
  DMA_Cmd(DMA2_Stream4, ENABLE);    // enabled during HT interrupt of other channel

  // enable ADC
  ADC_Cmd(ADC1, ENABLE);
  ADC_Cmd(ADC2, ENABLE);

  // sampling will start as soon as timer generates trigger
}

void DMA2_Stream0_IRQHandler(void){
  // transfer complete interrupt
  if(DMA_GetITStatus(DMA2_Stream0, DMA_IT_HTIF0)==SET){
    // clear pending interrupt
    DMA_ClearITPendingBit(DMA2_Stream0, DMA_IT_HTIF0);
    // enable other channel
    DMA_Cmd(DMA2_Stream4, ENABLE);
    // change buffer pointer to corresponding buffer
    adcBuffer.bufFFT = adcBuffer.bufA;

    // print buffer
    usart2Printf("bufA HT\n\r");
    for(int i=0;i<ADC_BUFFER_LENGTH;i++){
      itoa(adcBuffer.bufA[i],tmp,10);
      usart2Printf(tmp);
      usart2Printf("\t");
      itoa(adcBuffer.bufB[i],tmp,10);
      usart2Printf(tmp);
      usart2Printf("\n\r");
    }
  }
}

void DMA2_Stream4_IRQHandler(void){
  // transfer complete interrupt
  if(DMA_GetITStatus(DMA2_Stream4, DMA_IT_HTIF4)==SET){
    // clear pending interrupt
    DMA_ClearITPendingBit(DMA2_Stream4, DMA_IT_HTIF4);
    // enable other channel
    DMA_Cmd(DMA2_Stream0, ENABLE);
    // change buffer pointer to corresponding buffer
    adcBuffer.bufFFT = adcBuffer.bufB;

    // print buffer
    usart2Printf("bufB HT\n\r");
    for(int i=0;i<ADC_BUFFER_LENGTH;i++){
      itoa(adcBuffer.bufA[i],tmp,10);
      usart2Printf(tmp);
      usart2Printf("\t");
      itoa(adcBuffer.bufB[i],tmp,10);
      usart2Printf(tmp);
      usart2Printf("\n\r");
    }
  }
}

[Paul S. (mrpaul)]

Habe das "Problem" selbst lösen können.

Es funktioniert nicht, zwei DMA-Streams mit der gleichen Interruptquelle 
zu nutzen. Im Manual steht:

After an event, the peripheral sends a request signal to the DMA controller. The DMA controller serves the request depending on the channel priorities. As soon as the DMA controller accesses the peripheral, an Acknowledge signal is sent to the peripheral by the DMA controller. The peripheral releases its request as soon as it gets the Acknowledge signal from the DMA controller. Once the request has been deasserted by the peripheral, the DMA controller releases the Acknowledge signal.

Ich interpretiere das so, dass der Request sofort zurückgesetzt wird, 
sobald der erste Stream beginnt. Demzufolge "sieht" der zweite Stream 
den Request nicht mehr.

[Matthias L. (Gast)]

Paul S. schrieb:
> Ich interpretiere das so, dass der Request sofort zurückgesetzt wird,
> sobald der erste Stream beginnt. Demzufolge "sieht" der zweite Stream
> den Request nicht mehr.

Das macht ja auch Sinn. Immerhin sind die Daten ja korrekt per DMA 
übertragen worden. Warum dann nochmal? Du kannst sie ja von der neuen 
Position weiterverwenden.