STM32F4DiscoveryBoard und ADC

[opcode (Gast)]

Sehr geehrte Forummitglieder,

ich möchte mit dem STM32F4DiscoveryBoard (Controller: STM32F407VGT) ein 
analoges Signal abtasten. Dazu habe ich mir die Beispiele in den 
Libraries auf der Website von STMicroelectronis angeschaut. Da ich das 
Signal schnell abtasten muss, dachte ich an die Lösung mit Dual bzw. 
Triple Interleaved Mode with DMA2mode. Mit diesen Einstellungen kann ich 
mit mehr als 2MSPS abtasten. Sofern ich den unten angeführten 
Beispielcode verstanden habe, wird einmalig mit den drei ADC's im 
Controller der eine Kanal abgetastet und die drei Werte werden per DMA 
direkt in Speicher geladen, ohne die CPU zu unterbrechen. Ich möchte nun 
nicht nur einmal abtasten, sondern min. 4096 oder 8192. Gibt es eine 
Möglichkeit die Anzahl der Abtastungen direkt vorzugeben und alle diese 
Werte in den Speicher zu laden ohne mit Interrupts in der CPU zu 
arbeiten, wo quasi kontrolliert wird, wie viel Werte schon abgetastet 
wurden sind ?!

Ich bin für jede Hilfe dankbar und wünsche allen einen guten Rutsch ins 
neue Jahr.

mfGruß,
opcode

#include "stm32f4xx.h"
#include "stm32f4xx_adc.h"
#include "stm32f4xx_dma.h"
#include "stm32f4xx_gpio.h"
#include "stm32f4xx_rcc.h"


#define ADC_CDR_ADDRESS    ((uint32_t)0x40012308)
__IO uint32_t ADCTripleConvertedValue[3];

ADC_InitTypeDef       ADC_InitStructure;
ADC_CommonInitTypeDef ADC_CommonInitStructure;
DMA_InitTypeDef       DMA_InitStructure;
GPIO_InitTypeDef      GPIO_InitStructure;


int main(void)
{

  /******************************************************************************/
  /*               ADCs interface clock, pin and DMA configuration              */
  /******************************************************************************/

    /* Enable peripheral clocks */
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2 | RCC_AHB1Periph_GPIOC, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_ADC2 |
                           RCC_APB2Periph_ADC3, ENABLE);

    /* Configure ADC Channel 12 pin as analog input */
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ;
    GPIO_Init(GPIOC, &GPIO_InitStructure);

    /* DMA2 Stream0 channel0 configuration */
    DMA_InitStructure.DMA_Channel = DMA_Channel_0;
    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)ADC_CDR_ADDRESS;
    DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)&ADCTripleConvertedValue;
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
    DMA_InitStructure.DMA_BufferSize = 3;
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;
    DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
    DMA_InitStructure.DMA_Priority = DMA_Priority_High;
    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_Stream0, &DMA_InitStructure);

    /* DMA2_Stream0 enable */
    DMA_Cmd(DMA2_Stream0, ENABLE);


    /******************************************************************************/
    /*  ADCs configuration: triple interleaved with 5cycles delay to reach 6Msps  */
    /******************************************************************************/

      /* ADC Common configuration *************************************************/
      ADC_CommonInitStructure.ADC_Mode = ADC_TripleMode_Interl;
      ADC_CommonInitStructure.ADC_TwoSamplingDelay = ADC_TwoSamplingDelay_5Cycles;
      ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_2;
      ADC_CommonInitStructure.ADC_Prescaler = ADC_Prescaler_Div2;
      ADC_CommonInit(&ADC_CommonInitStructure);

      /* ADC1 regular channel 12 configuration ************************************/
      ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
      ADC_InitStructure.ADC_ScanConvMode = DISABLE;
      ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
      ADC_InitStructure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_None;
      ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
      ADC_InitStructure.ADC_NbrOfConversion = 1;
      ADC_Init(ADC1, &ADC_InitStructure);

      ADC_RegularChannelConfig(ADC1, ADC_Channel_12, 1, ADC_SampleTime_3Cycles);
      /* Enable ADC1 DMA */
      ADC_DMACmd(ADC1, ENABLE);

      /* ADC2 regular channel 12 configuration ************************************/
      ADC_Init(ADC2, &ADC_InitStructure);
      /* ADC2 regular channel12 configuration */
      ADC_RegularChannelConfig(ADC2, ADC_Channel_12, 1, ADC_SampleTime_3Cycles);

      /* ADC3 regular channel 12 configuration ************************************/
      ADC_Init(ADC3, &ADC_InitStructure);
      /* ADC3 regular channel12 configuration */
      ADC_RegularChannelConfig(ADC3, ADC_Channel_12, 1, ADC_SampleTime_3Cycles);

      /* Enable DMA request after last transfer (multi-ADC mode) ******************/
      ADC_MultiModeDMARequestAfterLastTransferCmd(ENABLE);

      /* Enable ADC1 **************************************************************/
      ADC_Cmd(ADC1, ENABLE);

      /* Enable ADC2 **************************************************************/
      ADC_Cmd(ADC2, ENABLE);

      /* Enable ADC3 **************************************************************/
      ADC_Cmd(ADC3, ENABLE);

      /* Start ADC1 Software Conversion */
      ADC_SoftwareStartConv(ADC1);

    while(1)
    {
    }
}

[Hansi-Bansi (Gast)]

> wird einmalig

Ich glaube nicht (Irrtum jedoch möglich)
so wie ich das sehe, läuft der ADC im continuierlichen Modus und die DMA 
im circular Modus. Das bedeutet, dass die drei Werte im Array ständig 
aktualisiert werden (endlos), sobald einmalig die Zeile 
"ADC_SoftwareStartConv(ADC1);" gestartet wurde.

An diesen Zeilen sieht man es:

circular Modus (Buffer immer wieder von Beginn an neu beschreiben (im 
Kreis also)):

DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;

Der ADC rödelt endlos vor sich hin, sobald einmal ausgelöst wurde 
(kontinuierlich ohne Trigger).

ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;

-------------------------------------------------------------

Wenn ich mich nicht täusche, so musst du im Code lediglich folgende 
Zeilen abändern, damit mehr Werte im Buffer landen:

Hier einfach die Buffergröße auf ein Vielfaches von 3 aufblasen (zB. 9)

__IO uint32_t ADCTripleConvertedValue[9];

Hier musst du dem DMA bescheid geben, dass der Buffer nun größer ist. 
Also die gleiche Zahl hintippen die auch dein Buffer als Größe hat:

DMA_InitStructure.DMA_BufferSize = 9;

Das sollte es eigentlich gewesen sein?! Irrtümer sind eingeschlossen. 
Ich habe zwar schon was mit dem ADC + DMA gemacht, aber ein absoluter 
Experte bin ich nicht. Ausprobieren macht schlau.

lg
Hansi

[veryBo (Gast)]

>Hier einfach die Buffergröße auf ein Vielfaches von 3 aufblasen (zB. >9)__IO 
uint32_t ADCTripleConvertedValue[9];

Nein.

DMA macht erst richtig Spass mit einem richtig fetten Puffer.
Sonst ist der Durchsatz nicht erreichbar. Daten einlesen ist ja kein 
Selbstzweck, sie müssen auch verarbeitet werden.
Bei einer Puffergrösse von 9 müsste die CPU jeweils nach
9 Werten ran. Wenn man das in einem Interrupt macht, könnte
man sich DMA gleich schenken.
Bei 2000 Werten sieht's schon anders aus.

[opcode (Gast)]

Bin jetzt verwirrt.

Kann ich jetzt das jetzt so machen wie Hansi es beschrieben hat ?!
Einfach die Buffergröße vergrößern ?!

[Hansi-Bansi (Gast)]

veryBo schrieb:
> DMA macht erst richtig Spass mit einem richtig fetten Puffer.
> Sonst ist der Durchsatz nicht erreichbar. Daten einlesen ist ja kein
> Selbstzweck, sie müssen auch verarbeitet werden.
> Bei einer Puffergrösse von 9 müsste die CPU jeweils nach
> 9 Werten ran. Wenn man das in einem Interrupt macht, könnte
> man sich DMA gleich schenken.
> Bei 2000 Werten sieht's schon anders aus.

Die Zahl 9 war auch nur ein Beispiel. Da erkennt man schön, dass es sich 
um ein Vielfaches von 3 handelt...

> Kann ich jetzt das jetzt so machen wie Hansi es beschrieben hat ?!
> Einfach die Buffergröße vergrößern ?!

Würde mich auch interessieren. 100% sicher bin ich mir nämlich nicht...

[veryBo (Gast)]

opcode schrieb:
> Bin jetzt verwirrt.
>
> Kann ich jetzt das jetzt so machen wie Hansi es beschrieben hat ?!
> Einfach die Buffergröße vergrößern ?!

JAHAAA!

Manche DMA-Controller haben allerdings eine Beschränkung,
hinsichtlich der Maximalgrösse eines einzelnen
Transfers (z.B. 8K oder 16K oder...).
Weiss allerdings nicht, ob das für den STM32F4 zutrifft.
Aber das steht sicher im Datenblatt.
Bist Du jetzt noch mehr verwirrt :-)?

[opcode (Gast)]

Jaaaaaaaaa, ich bin jetzt total verwirrt!!! ;-)

Danke für eure Hilfe !

Wünsche euch einen guten Rutsch ins neue Jahr!

mfGruß,
opcode