STM32 ADC DMA

[Hanspi (Gast)]

Ich bin neu auf dem Gebiet und habe eine simple Frage:

Ich habe einen ADC_DMA Transfer eingerichtet um Sensor-Werte einzulesen: 
HAL_ADC_Start_DMA(&hadc1, (uint32_t*)&ADC1ConvertedValue, 1)

Das funktioniert um stets die Variable ADC1ConvertedValue zu 
aktualisieren.

Aber wie kann ich die Buffer-Grösse einstellen? Schlussendlich möchte 
ich z.B. 1000 Sensor-Werte mittels DMA speichern, dann einen Interrupt 
erhalten und diese 1000 Werte alle aufs mal verarbeiten.

Vielen Dank und vergebt mir, falls die Frage dumm ist ;-)

[Bernd (Gast)]

Die Anzahl Sample pro Channel * Channelanzahl kommen bei mir nur im 
Startkommando als Buffergröße vor.
Aber der ADC und der DMA müssen natürlich richtig konfiguriert sein.
Ich sample 4 channel nacheinander in einer "regular group" jeweils 32 
mal hintereinander. Am Ende bekomme ich einen HAL_ADC_ConvCpltCallback() 
wo ich meinen Buffer auswerten kann. Ich stoppe dort den DMA und starte 
ihn später manuell wieder. Je Kanal bilde ich dann über die 32 
gesampelten Werte einen Mittelwert mit dem ich dann weiter arbeite. So 
bekomme ich bei jedem Conversion complete Callback 32 frische Werte je 
Kanal per DMA.


Hier ein paar Codeausschnitte auf einem STM32F429:

HAL_ADC_Start_DMA(&hadc3, (uint32_t*)ADC3_DMA_Buffer, ADC3_DMA_BUFFER_SIZE);

#define ADC3_DMA_NR_OF_CHANNELS  4
#define ADC3_DMA_NR_OF_SAMPLES  32  // muss eine Zweierpotenz sein
#define ADC3_DMA_BUFFER_SIZE  (ADC3_DMA_NR_OF_CHANNELS * ADC3_DMA_NR_OF_SAMPLES)  // es werden 4 ADC Channel je DMA Aufruf ADC3_DMA_NR_OF_SAMPLES mal gesampelt
extern volatile uint16_t ADC3_DMA_Buffer[];

static void ConfigureDMA2_Stream0(void)
{
    __DMA2_CLK_ENABLE();
    hadc3dma.Instance = DMA2_Stream0;

    hadc3dma.Init.Channel  = DMA_CHANNEL_2;
    hadc3dma.Init.Direction = DMA_PERIPH_TO_MEMORY;
    hadc3dma.Init.PeriphInc = DMA_PINC_DISABLE;
    hadc3dma.Init.MemInc = DMA_MINC_ENABLE;
    hadc3dma.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
    hadc3dma.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
    hadc3dma.Init.Mode = DMA_NORMAL;  // DMA_NORMAL is needed to avoid DMA buffer index shift if ADC is not stopped fast enough in continuous mode, if ADC not in continuous mode DMA_CIRCULAR is needed
    hadc3dma.Init.Priority = DMA_PRIORITY_HIGH;
    hadc3dma.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
    hadc3dma.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL;  // only relevant if FIFO mode enabled
    hadc3dma.Init.MemBurst = DMA_MBURST_SINGLE;
    hadc3dma.Init.PeriphBurst = DMA_PBURST_SINGLE;

    HAL_DMA_Init(&hadc3dma);

    __HAL_LINKDMA(&hadc3, DMA_Handle, hadc3dma);

    HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn);
}

// ADC3 init function
void MX_ADC3_Init(void)
{
  ADC_ChannelConfTypeDef sConfig;

    // Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)

  hadc3.Instance = ADC3;
  hadc3.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4;
  hadc3.Init.Resolution = ADC_RESOLUTION_12B;
  hadc3.Init.ScanConvMode = ENABLE;      // enables the sampling of a regular group
  hadc3.Init.ContinuousConvMode = ENABLE;  // continuous mode is needed to trigger with one DMA start more than one group conversion (but ADC must be disabled manually after DMA stream complete), if ADC not in continuous mode DMA_CIRCULAR is needed
  hadc3.Init.DiscontinuousConvMode = DISABLE;
  hadc3.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
  hadc3.Init.ExternalTrigConv = ADC_SOFTWARE_START;
  hadc3.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc3.Init.NbrOfConversion = 4;        // Anzahl der ADC channels in regular group
  hadc3.Init.DMAContinuousRequests = ENABLE;  // enable, sonst kann der DMA nur einmal gestartet werden
  hadc3.Init.EOCSelection = ADC_EOC_SEQ_CONV;  // hat bei DMA vermutlich keinen Einfluss
  if (HAL_ADC_Init(&hadc3) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

  __HAL_ADC_DISABLE(&hadc3);  // bei ExternalTrigConv = ADC_SOFTWARE_START eigentlich unnötig, aber vorsichtshalber trotzdemn ADC definitiv anhalten

    // Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

  sConfig.Channel = ADC3_CH_ACC_X;
  sConfig.Rank = 1;
  sConfig.SamplingTime = ADC_SAMPLETIME_15CYCLES;
  sConfig.Offset = 0;
  if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

  sConfig.Channel = ADC3_CH_ACC_Y;
  sConfig.Rank = 2;
  sConfig.SamplingTime = ADC_SAMPLETIME_15CYCLES;
  sConfig.Offset = 0;
  if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

  sConfig.Channel = ADC3_CH_ACC_Z;
  sConfig.Rank = 3;
  sConfig.SamplingTime = ADC_SAMPLETIME_15CYCLES;
  sConfig.Offset = 0;
  if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

  sConfig.Channel = ADC3_CH_POTI;
  sConfig.Rank = 4;
  sConfig.SamplingTime = ADC_SAMPLETIME_15CYCLES;
  sConfig.Offset = 0;
  if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

  ConfigureDMA2_Stream0();

  ADC3_inited = 1;
}

void DMA2_Stream0_IRQHandler(void)
{
// end of transfer
    HAL_DMA_IRQHandler(&hadc3dma);
}

void ADC_IRQHandler(void)
{
// seems to be not called with DMA?
    HAL_ADC_IRQHandler(&hadc3);
}

void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* adcHandle)
{
  if (adcHandle->Instance == ADC3) {
    // Stream transfer complete (can be after multiple ADC group scanns)
    __HAL_ADC_DISABLE(adcHandle);  // to interrupt ADC continuous mode
    // alle 3ms Start einer neuen ADC DMA Wandlung im HAL_SYSTICK_Callback()
    // Wandlung von 4 Kanälen mit den hier gemachten Einstellungen dauert ca.10us

// die Daten liegen immer so im Buffer ch1 ... ch4, ch1 ... ch4, ...
...
}

// einfacher Mittelwert über ADC_DMA_NR_OF_SAMPLES Werte
uint16_t md_ADC3_avgDMAvalues(ADC3_NAME_t adc_name) {
  uint32_t buffer = 0;
  uint16_t retVal;

  #if (ADC3_DMA_NR_OF_SAMPLES == 1)
    uint8_t anz_bit = 0;
    return ADC3_DMA_Buffer[adc_name];
  #elif (ADC3_DMA_NR_OF_SAMPLES == 2)
    uint8_t anz_bit = 1;
  #elif (ADC3_DMA_NR_OF_SAMPLES == 4)
    uint8_t anz_bit = 2;
  #elif (ADC3_DMA_NR_OF_SAMPLES == 8)
    uint8_t anz_bit = 3;
  #elif (ADC3_DMA_NR_OF_SAMPLES == 16)
    uint8_t anz_bit = 4;
  #elif (ADC3_DMA_NR_OF_SAMPLES == 32)
    uint8_t anz_bit = 5;
  #elif (ADC3_DMA_NR_OF_SAMPLES == 64)
    uint8_t anz_bit = 6;
  #elif (ADC3_DMA_NR_OF_SAMPLES == 128)
    uint8_t anz_bit = 7;
  #elif (ADC3_DMA_NR_OF_SAMPLES == 256)
    uint8_t anz_bit = 8;
  #elif (ADC3_DMA_NR_OF_SAMPLES == 512)
    uint8_t anz_bit = 9;
  #elif (ADC3_DMA_NR_OF_SAMPLES == 1024)
    uint8_t anz_bit = 10;
  #elif (ADC3_DMA_NR_OF_SAMPLES == 2048)
    uint8_t anz_bit = 11;
  #elif (ADC3_DMA_NR_OF_SAMPLES == 4096)
    uint8_t anz_bit = 12;
  #else
    #error no valid size for division by shifting
  #endif

  // in ADC_DMA_Buffer liegen immer die 4 ADC Kanäle hintereinander
  for (uint32_t i=adc_name; i < ADC3_DMA_BUFFER_SIZE; i=i+ADC3_DMA_NR_OF_CHANNELS) {
    buffer += ADC3_DMA_Buffer[i];
  }

  retVal = (buffer >> anz_bit);

  return retVal;
}