STM32F4: Triple ADC + Timer + DMA

[kuds (Gast)]

Hi,
ich habe ein STM32F407 und möchte die drei onboard-ADCs mit einem Timer 
(TIM2) getriggert via DMA (DMA2, Stream 4, Channel 0) auslesen. (Ein 
ganz ähnliches Problem hatten wir hier schonmal 
Beitrag "stm32F4 + ADC + Timer + DMA" )
Mein Timer läuft mit den Einstellungen in unten stehendem Code mit genau 
100Hz. Das habe ich auch mit einem "normalen" Interrupt getestet und 
nachgemessen.
In meiner DMA-Konfiguration verwende ich den TripleADC-Modus.

Das Problem ist, dass der DMA-Interrupt-Handler viel häufiger aufgerufen 
wird als er sollte... Ich denke also irgendwas läuft mit der Triggerung 
falsch oder ich muss an irgendeiner Stelle was deaktivieren. Ich weiß 
nur nicht wo.

Meine Funktion zum Konfigurieren des Timers:

void timer_init()
{
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
  TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
  TIM_TimeBaseStructure.TIM_Period = 99;  //diese kombi aus Period und Prescaler gibt 100 HZ (ist getestet!)
  TIM_TimeBaseStructure.TIM_Prescaler = 2099;
  TIM_TimeBaseStructure.TIM_ClockDivision =0;
  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);

  TIM_SelectOutputTrigger(TIM2, TIM_TRGOSource_Update);
}

Meine Funktion zur Konfiguration des DMAs:

void PDHADC_DMA_init()
{
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE); // Enable the DMA clock
  
  // Enable the DMA Stream IRQ Channel
  NVIC_InitTypeDef NVIC_InitStructure;
  NVIC_InitStructure.NVIC_IRQChannel = DMA2_Stream4_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

  DMA_InitTypeDef DMA_InitStructure;

  DMA_Cmd(DMA2_Stream4, DISABLE);
  DMA_DeInit(DMA2_Stream4);

  // Set the parameters to be configured
  DMA_InitStructure.DMA_Channel = DMA_Channel_0;         //use channel 0
  DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&ADC->CDR;    // Read from common mode register
  DMA_InitStructure.DMA_Memory0BaseAddr    = (uint32_t)&PDHADC_buffer[0]; // Send the data to the RAM buffer
  DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;     // periphery -- into --> memory
  DMA_InitStructure.DMA_BufferSize = 3;     //einfachster fall: DMA sollte nach einer Triple-ADC-Konversion auslösen.
  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;   //the periphery address stays the same
  DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;     //but the memory address is incremented (buffer[0], buffer[1], ... buffer[BUFFER_SIZE])
  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord; //16bit=Half Word (the actual data are only 12 bits)
  DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;  //buffer type is also 16bit.
  DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;        //if one reaches the end start from 0 again
  DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
  DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;       
  DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_HalfFull;   
  DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;     
  DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;   
  DMA_Init(DMA2_Stream4, &DMA_InitStructure);         //write the configuration
  
  DMA_ITConfig(DMA2_Stream4, DMA_IT_TC, ENABLE);// Enable DMA Transfer Complete (TC) interrupt
}

und der zugehörige Interrupt-Handler:

extern "C" void DMA2_Stream4_IRQHandler(void)
{
  if (DMA_GetITStatus(DMA2_Stream4, DMA_IT_TCIF4))
  {
        //hier kommt spaeter noch was hin...
  DMA_ClearITPendingBit(DMA2_Stream4, DMA_IT_TCIF4);
   }
}

Meine Funktion zur Konfiguration des Triple-ADC:

void ADC_init()
{
  //create init structures
  GPIO_InitTypeDef GPIO_InitStructure;
  ADC_InitTypeDef ADC_InitStructure;
  ADC_CommonInitTypeDef ADC_CommonInitStructure;

  //configure ADC_Common
  ADC_CommonInitStructure.ADC_Mode = ADC_TripleMode_RegSimult;   //ADC1 as master, ADC2+3 as slaves
  ADC_CommonInitStructure.ADC_Prescaler = ADC_Prescaler_Div2;    //default
  ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_1; //ADC1[0], ADC2[0], ADC3[0], ADC1[1], ADC2[1]...
  ADC_CommonInitStructure.ADC_TwoSamplingDelay = ADC_TwoSamplingDelay_20Cycles;
  ADC_CommonInit(&ADC_CommonInitStructure);

  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE); //enable clocks for ADC pins (A0, A1, A2) 
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 |RCC_APB2Periph_ADC3 |RCC_APB2Periph_ADC3, ENABLE); //enable clock for ADCs itself

  //configure ADC pins is analog input.
  GPIO_InitStructure.GPIO_Pin =GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  ADC_InitStructure.ADC_Resolution=ADC_Resolution_12b;  //12bit
  ADC_InitStructure.ADC_ScanConvMode = DISABLE;     //only 1 channel per ADC --> no scan
  ADC_InitStructure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_Rising; //trigger on rising edge of trigger event
  ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;  //only one conversion per trigger event?
  ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T2_TRGO; //triggered by TIM2 
  ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;   // 0b0000(Bit12)(Bit11)....(Bit0) with Bit12 being MSB
  ADC_InitStructure.ADC_NbrOfConversion = 1;     //only one channel per ADC

  ADC_Init(ADC1, &ADC_InitStructure); //master
  //hier bin ich unsicher... kann ich mit dem selben struct auch ADC2 und ADC3 (die slaves) initialisieren?
  ADC_Init(ADC2, &ADC_InitStructure); 
  ADC_Init(ADC3, &ADC_InitStructure);

  ADC_RegularChannelConfig(ADC1, ADC_Channel_0, 1, ADC_SampleTime_15Cycles);
  ADC_RegularChannelConfig(ADC2, ADC_Channel_1, 1, ADC_SampleTime_15Cycles);
  ADC_RegularChannelConfig(ADC3, ADC_Channel_2, 1, ADC_SampleTime_15Cycles);

  ADC_MultiModeDMARequestAfterLastTransferCmd(ENABLE);
}

Ich starte mein Programm folgendermaßen:

...
timer_init();
dma_init();
adc_init();

...
TIM_Cmd(TIM2, ENABLE);
DMA_Cmd(DMA2_Stream4, ENABLE);
ADC_DMACmd(ADC1, ENABLE);
//ADC_DMACmd(ADC2, ENABLE); //die slaves hier brauch ich nicht, oder?
//ADC_DMACmd(ADC3, ENABLE);

ADC_Cmd(ADC1,ENABLE);
ADC_Cmd(ADC2,ENABLE);
ADC_Cmd(ADC3,ENABLE);
ADC_SoftwareStartConv(ADC1);
...

Wie gesagt: Das Problem ist, dass der DMA Interrupt-Handler viel zu 
häufig aufgerufen wird; also viel häufiger als 100Hz, die der TIM2 
vorgeben sollte. Die Kopplung von Timer und ADC/DMA scheint also nicht 
zu funktionieren. Habt ihr eine Idee?

Vielen Dank für eure Hilfe!

[kuds (Gast)]

Lösung selbst gefunden. Für alle, die ein ähnliches Problem haben:
Es kommt auf die Initialisierungsreihenfolge an!
Folgende Reihenfolge funktioniert bei mir:
1. RCC
2. NVIC
3. DMA
4. GPIO
5. TIM
6. ADC

[kuds (Gast)]

und das
ADC_DMACmd(ADC1, ENABLE)
braucht man NICHT!

[Marcus H. (Firma: www.harerod.de) (lungfish)]

kuds schrieb:
> Lösung selbst gefunden. Für alle, die ein ähnliches Problem haben:
> Es kommt auf die Initialisierungsreihenfolge an!
> Folgende Reihenfolge funktioniert bei mir:
> 1. RCC
> 2. NVIC
> 3. DMA
> 4. GPIO
> 5. TIM
> 6. ADC

Mmmh, spontan hätte ich die Initialisierung in dieser Reihenfolge 
durchgeführt:

1. RCC    <- Power!
4. GPIO   <- Portpins aktivieren
6. ADC    <- ADC parametrieren
2. NVIC   <- Interrupt-System parametrieren
3. DMA    <- DMA Kanäle parametrieren
5. TIM    <- Timer loslaufen lassen