STM32 ADC DMA

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;

}