STM32 ADC->DMA Continous mode lässt sich nicht aktivieren

[Solocan Z. (solocan)]

Hallo zusammen,

ich stehe gerade auf dem Schlauch und brauche Inputs. Ich möchte, dass 
die ADC Werte per DMA kontinuierlich im Hintergrund auf eine 
Speicheradresse geschrieben werden. Doch DMA wird nur 1 mal getriggert 
und hört dann auf. Im Polling mode kriege ich Updates, im DMA nicht. 
Scheint so, dass ich DMA irgendwie falsch konfiguriert habe aber finde 
meinen Fehler einfach nicht. Alles mit "continuous" und "discontinuous" 
bereits erfolglos versucht.

Hier ist der relevante Auszug ausm Code:

main.c

int main(void)
{
 
  HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_USART3_UART_Init();
  MX_USB_OTG_FS_PCD_Init();
  MX_ADC1_Init();

  uint16_t ADC_buf=0;
  uint16_t ADC_poll=0;

  //Start DMA stream
  HAL_ADC_Start_DMA(&hadc1,(uint32_t*) &ADC_buf,2);

  while(1){

    HAL_ADC_Start(&hadc1);
    HAL_ADC_PollForConversion(&hadc1,10);
    ADC_poll=HAL_ADC_GetValue(&hadc1);
    printf("DMA: %d \t Poll: %d\n",(int) ADC_buf, (int)ADC_poll);

    HAL_ADC_Stop(&hadc1);
    HAL_Delay(100);
.
.
.
static void MX_ADC1_Init(void)
{

  ADC_ChannelConfTypeDef sConfig;

    /**Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)
    */
  hadc1.Instance = ADC1;
  hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4;
  hadc1.Init.Resolution = ADC_RESOLUTION_12B;
  hadc1.Init.ScanConvMode = ADC_SCAN_ENABLE;
  hadc1.Init.ContinuousConvMode = ENABLE;
  hadc1.Init.DiscontinuousConvMode = DISABLE;
  hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
  hadc1.Init.ExternalTrigConv =ADC_SOFTWARE_START ;
  hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc1.Init.NbrOfConversion = 2;
  hadc1.Init.DMAContinuousRequests = ENABLE;
  hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
  if (HAL_ADC_Init(&hadc1) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

    /**Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.
    */
  sConfig.Channel = ADC_CHANNEL_0;
  sConfig.Rank = ADC_REGULAR_RANK_1;
  sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

}

static void MX_DMA_Init(void) 
{
  /* DMA controller clock enable */
  __HAL_RCC_DMA2_CLK_ENABLE();

  /* DMA interrupt init */
  hdma_adc1.Instance=DMA2_Stream0;
  hdma_adc1.Init.Channel = DMA_CHANNEL_0;// Channel 0, Stream 0
  hdma_adc1.Init.Direction=DMA_PERIPH_TO_MEMORY;
  hdma_adc1.Init.PeriphInc=DMA_PINC_DISABLE;
  hdma_adc1.Init.MemInc=DMA_MINC_DISABLE;
  hdma_adc1.Init.PeriphDataAlignment=DMA_PDATAALIGN_HALFWORD;
  hdma_adc1.Init.MemDataAlignment=DMA_MDATAALIGN_HALFWORD;
  hdma_adc1.Init.Mode=DMA_CIRCULAR;
  hdma_adc1.Init.Priority=DMA_PRIORITY_HIGH;
  hdma_adc1.Init.FIFOMode=DMA_FIFOMODE_DISABLE;
  hdma_adc1.Init.FIFOThreshold=DMA_FIFO_THRESHOLD_HALFFULL;
  hdma_adc1.Init.MemBurst=DMA_MBURST_SINGLE;
  hdma_adc1.Init.PeriphBurst=DMA_PBURST_SINGLE;

  //Initialize DMA
  if (HAL_DMA_Init(&hdma_adc1) != HAL_OK)    {      _Error_Handler(__FILE__, __LINE__);    }  ;

  /* DMA2_Stream0_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn);


}

stm32f7xx_it.c

void DMA2_Stream0_IRQHandler(void)
{

  printf("Interrupted\n");
  HAL_DMA_IRQHandler(&hdma_adc1);
}

printf-Ausgabe ist:

Initializing
Interrupted
DMA: 4095    Poll: 4034
DMA: 4095    Poll: 4032
DMA: 4095    Poll: 4095
DMA: 4095    Poll: 4041
DMA: 4095    Poll: 4095
DMA: 4095    Poll: 4048
DMA: 4095    Poll: 4095
DMA: 4095    Poll: 4052
DMA: 4095    Poll: 4095
DMA: 4095    Poll: 4041

Also DMA bzw. interrupt nur 1x getriggert. Was konfiguriere ich denn 
hier falsch?

Bin nur hier nicht sicher:

hadc1.Init.ExternalTrigConv =ADC_SOFTWARE_START ;

Hier kann man auch verschiedene Timer wählen aber es half auch nichts.

Bin dankbar für jeden Tipp.

[Solocan Z. (solocan)]

Ich entnehme dem Datenblatt, dass es auf jeden Fall mit 
"ExternalTrigConv =ADC_SOFTWARE_START" und "ContinuousConvMode = ENABLE" 
in kontinuierlichen Modus wechseln soll. Also sobald eine Konvertierung 
durch ist, startet die nächste. Da bin ich mir eigentlich doch ziemlich 
sicher, dass ich ADC richtig konfiguriert habe.

Aber ich sehe auch, dass in der Beschreibung von der Funktion 
HAL_ADC_Start_DMA nur der "Single mode" steht. Es ist wahrscheinlich so, 
dass HAL für ADC-DMA Modus nur den Single mode unterstützt. (Ich habe 
versucht, die HAL-Funktion zu analysieren und es sieht tatsächlich so 
aus, dass HAL_ADC_Start_DMA jedes mal von außen getriggert werden muss.) 
Ich brauche aber einen kontinuierlichen Stream und möchte dass DMA im 
Hintergrund läuft und ich nicht per Software triggern muss. Hat das 
schon jemand gemacht? Muss ich da unbedingt einen Timer einstellen?

[geb (Gast)]

Hier der Code, wie ich es für ADC3 getriggert durch Timer 3 gemacht 
habe. Vergiss nicht die Clocks einzuschalten und den DMA Interrupt zu 
konfigurieren.

void init_ADC(void)
{
#define ADC1_DR_Address    ((u32)0x4001244C)
#define ADC3_DR_Address    ((u32)0x40013C4C)
DMA_InitTypeDef DMA_InitStructure;
ADC_InitTypeDef ADC_InitStructure;
TIM_TimeBaseInitTypeDef   TIM_TimeBaseStructure;
TIM_OCInitTypeDef         TIM_OCInitStructure;

 /* TIM3CC1 configuration 
------------------------------------------------------*/
  /* Time Base configuration*/
  TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
  TIM_TimeBaseStructure.TIM_Period = 36000;
  TIM_TimeBaseStructure.TIM_Prescaler = 0x1;
  TIM_TimeBaseStructure.TIM_ClockDivision = 0x0;
  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);
  TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_Pulse = 0x3F;
  TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_Low;
  TIM_OC1Init(TIM3, &TIM_OCInitStructure);
  TIM_OC1PreloadConfig(TIM3, TIM_OCPreload_Enable);



  ADC_buf_wr_ptr = ADC_buf_A;
  ADC_buf_rd_ptr = ADC_buf_B;
  DevStatus.TCmux =0;
  DevStatus.num_avg=0;


 //Mbox ADC3 DMA
  DMA_DeInit(DMA2_Channel5);
  DMA_InitStructure.DMA_PeripheralBaseAddr = ADC3_DR_Address;
  DMA_InitStructure.DMA_MemoryBaseAddr = (u32)ADC_buf_wr_ptr;
  DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
  DMA_InitStructure.DMA_BufferSize = 12;
  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  DMA_InitStructure.DMA_PeripheralDataSize = 
DMA_PeripheralDataSize_HalfWord;
  DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
  DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
  DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
  DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
  DMA_Init(DMA2_Channel5, &DMA_InitStructure);
  DMA_ITConfig(DMA2_Channel5, DMA_IT_TC, ENABLE);

   DMA_Cmd(DMA2_Channel1, DISABLE);
  DMA_Cmd(DMA2_Channel2, DISABLE);
  DMA_Cmd(DMA2_Channel3, DISABLE);
  DMA_Cmd(DMA2_Channel4, DISABLE);
  DMA_Cmd(DMA2_Channel5, ENABLE);

  /* ADC3 configuration 
------------------------------------------------------*/
  ADC_DeInit( ADC3);
  ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
  ADC_InitStructure.ADC_ScanConvMode = ENABLE;
  ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
//  ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
  ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T3_CC1;
  ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
  ADC_InitStructure.ADC_NbrOfChannel = 12;
  ADC_Init(ADC3, &ADC_InitStructure);
  /* ADC3 regular channel configuration */
  ADC_RegularChannelConfig(ADC3, ADC_Channel_4, 1, 
ADC_SampleTime_239Cycles5);//AIN_T_KK
  ADC_RegularChannelConfig(ADC3, ADC_Channel_7, 2, 
ADC_SampleTime_239Cycles5);//AIN420_1
  ADC_RegularChannelConfig(ADC3, ADC_Channel_8, 3, 
ADC_SampleTime_239Cycles5);//AIN420_2
  ADC_RegularChannelConfig(ADC3, ADC_Channel_10, 4, 
ADC_SampleTime_239Cycles5);//AIN420_3
  ADC_RegularChannelConfig(ADC3, ADC_Channel_11, 5, 
ADC_SampleTime_239Cycles5);//AIN420_4
  ADC_RegularChannelConfig(ADC3, ADC_Channel_12, 6, 
ADC_SampleTime_239Cycles5);//AIN420_5
  ADC_RegularChannelConfig(ADC3, ADC_Channel_13, 7, 
ADC_SampleTime_239Cycles5);//AIN420_6
  ADC_RegularChannelConfig(ADC3, ADC_Channel_5, 8, 
ADC_SampleTime_239Cycles5);//AIN_T_TC1
  ADC_RegularChannelConfig(ADC3, ADC_Channel_6, 9, 
ADC_SampleTime_239Cycles5);//AIN_T_TC2
  ADC_RegularChannelConfig(ADC3, ADC_Channel_0, 10, 
ADC_SampleTime_239Cycles5);//AIN_T_TC3
  ADC_RegularChannelConfig(ADC3, ADC_Channel_1, 11, 
ADC_SampleTime_239Cycles5);//AIN_T_TC4
  ADC_RegularChannelConfig(ADC3, ADC_Channel_3, 12, 
ADC_SampleTime_239Cycles5);//AIN_T_TC5
 //Init TC MUX
              CLR_TC1_A0;
              CLR_TC2_A0;
              CLR_TC1_A1;
              CLR_TC2_A1;
 DevStatus.TCmux=0;

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

 /* Enable ADC1 reset calibaration register */
  ADC_ResetCalibration(ADC3);
  /* Check the end of ADC1 reset calibration register */
      while(ADC_GetResetCalibrationStatus(ADC3));
  /* Start ADC1 calibaration */
  ADC_StartCalibration(ADC3);
  /* Check the end of ADC1 calibration */
  while(ADC_GetCalibrationStatus(ADC3));
  /* Enable ADC1 reset calibaration register */
TIM_Cmd(TIM3, ENABLE);//ADC startet noch nicht, erst durch Ext. Trigger 
command
}