Zwei ADC über DMA laufen lassen STM32

[Bert S. (kautschuck)]

Ich versuche ADC1 und ADC2 über den DMA auszulesen, doch bleibt das 
Programm in der Interrupt Routine vom DMA für den ADC1 Channel hängen.
Ich verwende HAL und habe die ADC's nach den Bildern im Anhang 
konfiguriert.

Ich starte die ADC's folgendermassen:

HAL_ADC_Start_DMA(&hadc1, (uint16_t*)adc_array, ADC_SIZE);
HAL_ADC_Start_DMA(&hadc2, (uint16_t*)adc_array2, ADC_SIZE);

Wenn ich aber nur HAL_ADC_Start_DMA(&hadc1, (uint16_t*)adc_array, 
ADC_SIZE); ausführe und nicht noch die zweite Codezeile, dann 
funktioniert es. Jemand eine Idee warum das in der Interrupt Routine vom 
DMA (welche man ja nicht deaktivieren kann) hängen bleibt?

EDIT: Anscheinend liegt es nur an ADC2, denn HAL_ADC_Start_DMA(&hadc2, 
(uint16_t*)adc_array2, ADC_SIZE); geht auch nicht, wenn ich die erste 
Codezeile auskommentiere.

Datenblatt (STM32F303K8T6):
http://www.st.com/content/ccc/resource/technical/document/reference_manual/4a/19/6e/18/9d/92/43/32/DM00043574.pdf/files/DM00043574.pdf/jcr:content/translations/en.DM00043574.pdf

[Jim M. (turboj)]

Wie sehen Deinen Quellcode nicht, und meine Glaskugel ist in Reparatur.

[Bert S. (kautschuck)]

Die ADC's sind wie folgt initialisiert und werden über die oben 
genannten zwei Codezeilen gestartet.

static void MX_ADC1_Init(void)
{

  ADC_MultiModeTypeDef multimode;
  ADC_ChannelConfTypeDef sConfig;

    /**Common config 
    */
  hadc1.Instance = ADC1;
  hadc1.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV1;
  hadc1.Init.Resolution = ADC_RESOLUTION_12B;
  hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
  hadc1.Init.ContinuousConvMode = DISABLE;
  hadc1.Init.DiscontinuousConvMode = DISABLE;
  hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_RISING;
  hadc1.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T2_TRGO;
  hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc1.Init.NbrOfConversion = 1;
  hadc1.Init.DMAContinuousRequests = ENABLE;
  hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
  hadc1.Init.LowPowerAutoWait = DISABLE;
  hadc1.Init.Overrun = ADC_OVR_DATA_OVERWRITTEN;
  if (HAL_ADC_Init(&hadc1) != HAL_OK)
  {
    Error_Handler();
  }

    /**Configure the ADC multi-mode 
    */
  multimode.Mode = ADC_MODE_INDEPENDENT;
  if (HAL_ADCEx_MultiModeConfigChannel(&hadc1, &multimode) != HAL_OK)
  {
    Error_Handler();
  }

    /**Configure Regular Channel 
    */
  sConfig.Channel = ADC_CHANNEL_4;
  sConfig.Rank = 1;
  sConfig.SingleDiff = ADC_SINGLE_ENDED;
  sConfig.SamplingTime = ADC_SAMPLETIME_601CYCLES_5;
  sConfig.OffsetNumber = ADC_OFFSET_NONE;
  sConfig.Offset = 0;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }

}

/* ADC2 init function */
static void MX_ADC2_Init(void)
{

  ADC_ChannelConfTypeDef sConfig;

    /**Common config 
    */
  hadc2.Instance = ADC2;
  hadc2.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV1;
  hadc2.Init.Resolution = ADC_RESOLUTION_12B;
  hadc2.Init.ScanConvMode = ADC_SCAN_ENABLE;
  hadc2.Init.ContinuousConvMode = DISABLE;
  hadc2.Init.DiscontinuousConvMode = DISABLE;
  hadc2.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc2.Init.NbrOfConversion = 2;
  hadc2.Init.DMAContinuousRequests = ENABLE;
  hadc2.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
  hadc2.Init.LowPowerAutoWait = DISABLE;
  hadc2.Init.Overrun = ADC_OVR_DATA_OVERWRITTEN;
  if (HAL_ADC_Init(&hadc2) != HAL_OK)
  {
    Error_Handler();
  }

    /**Configure Regular Channel 
    */
  sConfig.Channel = ADC_CHANNEL_1;
  sConfig.Rank = 1;
  sConfig.SingleDiff = ADC_SINGLE_ENDED;
  sConfig.SamplingTime = ADC_SAMPLETIME_181CYCLES_5;
  sConfig.OffsetNumber = ADC_OFFSET_NONE;
  sConfig.Offset = 0;
  if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }

    /**Configure Regular Channel 
    */
  sConfig.Channel = ADC_CHANNEL_2;
  sConfig.Rank = 2;
  if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }

}

[Christopher J. (christopher_j23)]

Bert S. schrieb:
> Ich verwende HAL und habe die ADC's nach den Bildern im Anhang
> konfiguriert.

Ist das malen nach Zahlen?

Bert S. schrieb:
> Ich versuche ADC1 und ADC2 über den DMA auszulesen, doch bleibt das
> Programm in der Interrupt Routine vom DMA für den ADC1 Channel hängen.

Welche DMA? Ich sehe nur die Konfiguration des ADC.

Bert S. schrieb:
> Jemand eine Idee warum das in der Interrupt Routine vom
> DMA (welche man ja nicht deaktivieren kann) hängen bleibt?

Welche Interrupt-Routine? Ich sehe keine. Eine Interrupt-Routine die man 
nicht deaktivieren kann halte ich übrigens für ein Gerücht. Allerdings 
macht für mich DMA ohne Interrupt eher keinen Sinn. Du willst doch 
wissen wann der Buffer voll ist, oder nicht? Warum willst du den 
Interrupt deaktivieren?

[Dr. Sommer (Gast)]

Bert S. schrieb:
> Jemand eine Idee warum das in der Interrupt Routine vom DMA (welche man
> ja nicht deaktivieren kann) hängen bleibt?

Vielleicht weiß das ja der Debugger, der kann dir sogar genau die Zeile 
sagen in der es stecken bleibt. Sich diese Zeile anzusehen kann ungemein 
helfen im Vergleich zum kompletten Blindflug und raten.

[Christian J. (Gast)]

Dr. Sommer schrieb:
> Vielleicht weiß das ja der Debugger, der kann dir sogar genau die Zeile
> sagen in der es stecken bleibt.

Zumindest bei EmBitz habe ich die Erfahrung gemacht, dass wenn es 
"hängt", dann auch so, dass der swd Debugger sich nicht mehr stoppen 
lässt. Das sind bei mir inzwischen 2/3 aller Fälle, wo echt was schief 
läuft. Meine DMA Frickelei mit dem ADC habe ich auch im Blindflug 
erstellt, da es öfter mal die "Hardware Default Exception" gab und da 
ich von Asm eh Null Plan habe, ich da auch nicht weiter reingekrochen 
bin.

[Bert S. (kautschuck)]

So, ich habe mich dem Problem nochmals angenommen, jedoch immer noch 
keine Lösung gefunden. Ich verwende gemäß dem folgenden Datenblatt den 
Dual regular simultaneous mode:
http://www.st.com/content/ccc/resource/technical/document/application_note/48/64/0d/61/be/65/48/ae/DM00069390.pdf/files/DM00069390.pdf/jcr:content/translations/en.DM00069390.pdf

Die initialisierung erfolgt so:

int main(void)
{

  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration----------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_TIM2_Init();
  MX_ADC1_Init();
  MX_ADC2_Init();

  /* USER CODE BEGIN 2 */

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */

  //TIMER
  HAL_TIM_OC_Start_IT(&htim2,TIM_CHANNEL_1) ; //Start Timer 2, Channel 1
  HAL_TIM_OC_Start_IT(&htim2,TIM_CHANNEL_2) ; //Start Timer 2, Channel 2
  HAL_TIM_OC_Start_IT(&htim2,TIM_CHANNEL_3) ; //Start Timer 2, Channel 3
  HAL_TIM_OC_Start_IT(&htim2,TIM_CHANNEL_4) ; //Start Timer 2, Channel 4


  HAL_ADCEx_Calibration_Start(&hadc1,ADC_SINGLE_ENDED);
  HAL_ADCEx_Calibration_Start(&hadc2,ADC_SINGLE_ENDED);

  HAL_ADCEx_MultiModeStart_DMA(&hadc1, adc_array, 99);


  while (1)
  {

  }
  /* USER CODE END 3 */

}

/* ADC1 init function */
static void MX_ADC1_Init(void)
{

  ADC_MultiModeTypeDef multimode;
  ADC_ChannelConfTypeDef sConfig;

    /**Common config 
    */
  hadc1.Instance = ADC1;
  hadc1.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV1;
  hadc1.Init.Resolution = ADC_RESOLUTION_12B;
  hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
  hadc1.Init.ContinuousConvMode = DISABLE;
  hadc1.Init.DiscontinuousConvMode = DISABLE;
  hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_RISING;
  hadc1.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T2_TRGO;
  hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc1.Init.NbrOfConversion = 1;
  hadc1.Init.DMAContinuousRequests = ENABLE;
  hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
  hadc1.Init.LowPowerAutoWait = DISABLE;
  hadc1.Init.Overrun = ADC_OVR_DATA_OVERWRITTEN;
  if (HAL_ADC_Init(&hadc1) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

    /**Configure the ADC multi-mode 
    */
  multimode.Mode = ADC_DUALMODE_REGSIMULT;
  multimode.DMAAccessMode = ADC_DMAACCESSMODE_12_10_BITS;
  multimode.TwoSamplingDelay = ADC_TWOSAMPLINGDELAY_1CYCLE;
  if (HAL_ADCEx_MultiModeConfigChannel(&hadc1, &multimode) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

    /**Configure Regular Channel 
    */
  sConfig.Channel = ADC_CHANNEL_4;
  sConfig.Rank = 1;
  sConfig.SingleDiff = ADC_SINGLE_ENDED;
  sConfig.SamplingTime = ADC_SAMPLETIME_601CYCLES_5;
  sConfig.OffsetNumber = ADC_OFFSET_NONE;
  sConfig.Offset = 0;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

}

/* ADC2 init function */
static void MX_ADC2_Init(void)
{

  ADC_ChannelConfTypeDef sConfig;

    /**Common config 
    */
  hadc2.Instance = ADC2;
  hadc2.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV1;
  hadc2.Init.Resolution = ADC_RESOLUTION_12B;
  hadc2.Init.ScanConvMode = ADC_SCAN_ENABLE;
  hadc2.Init.ContinuousConvMode = DISABLE;
  hadc2.Init.DiscontinuousConvMode = DISABLE;
  hadc2.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc2.Init.NbrOfConversion = 2;
  hadc2.Init.DMAContinuousRequests = ENABLE;
  hadc2.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
  hadc2.Init.LowPowerAutoWait = DISABLE;
  hadc2.Init.Overrun = ADC_OVR_DATA_OVERWRITTEN;
  if (HAL_ADC_Init(&hadc2) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

    /**Configure Regular Channel 
    */
  sConfig.Channel = ADC_CHANNEL_1;
  sConfig.Rank = 1;
  sConfig.SingleDiff = ADC_SINGLE_ENDED;
  sConfig.SamplingTime = ADC_SAMPLETIME_181CYCLES_5;
  sConfig.OffsetNumber = ADC_OFFSET_NONE;
  sConfig.Offset = 0;
  if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

    /**Configure Regular Channel 
    */
  sConfig.Channel = ADC_CHANNEL_2;
  sConfig.Rank = 2;
  if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

}

void HAL_ADC_MspInit(ADC_HandleTypeDef* hadc)
{

  GPIO_InitTypeDef GPIO_InitStruct;
  if(hadc->Instance==ADC1)
  {
  /* USER CODE BEGIN ADC1_MspInit 0 */

  /* USER CODE END ADC1_MspInit 0 */
    /* Peripheral clock enable */
    HAL_RCC_ADC12_CLK_ENABLED++;
    if(HAL_RCC_ADC12_CLK_ENABLED==1){
      __HAL_RCC_ADC12_CLK_ENABLE();
    }
  
    /**ADC1 GPIO Configuration    
    PA3     ------> ADC1_IN4 
    */
    GPIO_InitStruct.Pin = GPIO_PIN_3;
    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    /* ADC1 DMA Init */
    /* ADC1 Init */
    hdma_adc1.Instance = DMA1_Channel1;
    hdma_adc1.Init.Direction = DMA_PERIPH_TO_MEMORY;
    hdma_adc1.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_adc1.Init.MemInc = DMA_MINC_ENABLE;
    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_MEDIUM;
    if (HAL_DMA_Init(&hdma_adc1) != HAL_OK)
    {
      _Error_Handler(__FILE__, __LINE__);
    }

    __HAL_LINKDMA(hadc,DMA_Handle,hdma_adc1);

  /* USER CODE BEGIN ADC1_MspInit 1 */

  /* USER CODE END ADC1_MspInit 1 */
  }
  else if(hadc->Instance==ADC2)
  {
  /* USER CODE BEGIN ADC2_MspInit 0 */

  /* USER CODE END ADC2_MspInit 0 */
    /* Peripheral clock enable */
    HAL_RCC_ADC12_CLK_ENABLED++;
    if(HAL_RCC_ADC12_CLK_ENABLED==1){
      __HAL_RCC_ADC12_CLK_ENABLE();
    }
  
    /**ADC2 GPIO Configuration    
    PA4     ------> ADC2_IN1
    PA5     ------> ADC2_IN2 
    */
    GPIO_InitStruct.Pin = GPIO_PIN_4|GPIO_PIN_5;
    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    /* ADC2 DMA Init */
    /* ADC2 Init */
    hdma_adc2.Instance = DMA1_Channel2;
    hdma_adc2.Init.Direction = DMA_PERIPH_TO_MEMORY;
    hdma_adc2.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_adc2.Init.MemInc = DMA_MINC_ENABLE;
    hdma_adc2.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
    hdma_adc2.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
    hdma_adc2.Init.Mode = DMA_CIRCULAR;
    hdma_adc2.Init.Priority = DMA_PRIORITY_MEDIUM;
    if (HAL_DMA_Init(&hdma_adc2) != HAL_OK)
    {
      _Error_Handler(__FILE__, __LINE__);
    }

    __HAL_LINKDMA(hadc,DMA_Handle,hdma_adc2);

  /* USER CODE BEGIN ADC2_MspInit 1 */

  /* USER CODE END ADC2_MspInit 1 */
  }

}

[Robin S. (der_r)]

Ich habe leider nicht die Zeit und das Board, um dein Problem selber 
nachzuvollziehen. Aber ich weiß, dass bei den BluePill-Boards 
(STM32F103) der D.R.Simultaneous Mode so funktioniert, dass die DMA die 
Werte beider ADC auf das Datenregister von ADC1 vereint (obere 16 Bit = 
ADC2, untere = ADC1) und du sie von dort aus abholst.

Das hatte ich auch schon funktionierend in Betrieb genommen, wenn du 
magst, suche ich mal den Quellcode raus, vielleicht hilft dir das als 
Denkanstoß auch für deinen F3.

[Christopher J. (christopher_j23)]

Beim F3 ist das ganz ähnlich. Da landen beide Werte im "Common Data 
Register", also in ADC12_CDR bzw. ADC34_CDR, je nachdem ob man ADC1 und 
ADC2 bzw. ADC3 und ADC4 zusammen nutzt. Es gibt dazu von ST jeweils eine 
Appnote "STM32 ADC modes and their applications". Für den F3 wäre das 
diese hier:
www.st.com/resource/en/application_note/dm00069390.pdf

In dem Fall wird das aber nichts mit dem Auslesen aus dem CDR, weil im 
ADC1 nur ein Kanal gesamplet wird und bei ADC2 sind es zwei Kanäle. Das 
macht aber nichts, weil man wie gehabt beide ADCs einzeln auslesen kann, 
d.h. man startet einen DMA-Transfer bei jedem EOC-Ereignis. Aber machst 
du das denn auch? Ich glaube nicht.

Bert S. schrieb:
> multimode.DMAAccessMode = ADC_DMAACCESSMODE_12_10_BITS;

Hier hast du das User Manual für den HAL des F3: 
www.st.com/resource/en/user_manual/dm00122016.pdf

Den ominösen Interrupt-Handler in dem angeblich alles hängenbleibt sehe 
ich übrigens immer noch nicht.

[Bert S. (kautschuck)]

Zumindest funktioniert jetzt das auslesen beider ADC's mit dem 
Multimode, aber eben nur 1 Channel von ADC2. Das Problem war, dass ich 
den DMA nur im HalfWord Modus betrieben hatte.

Christopher J. schrieb:
> Es gibt dazu von ST jeweils eine
> Appnote "STM32 ADC modes and their applications". Für den F3 wäre das
> diese hier:

Dort steht ja drin, dass man beide DMA verwenden kann, doch ich blicke 
nicht durch wie ich hier denn Multimode starte und zwei verschiedene 
Buffer übergebe? Ich muss das auslesen ja mit folgendem Befehl starten:

HAL_ADCEx_MultiModeStart_DMA(&hadc1, adc_array, 100);

Christopher J. schrieb:
> Den ominösen Interrupt-Handler in dem angeblich alles hängenbleibt sehe
> ich übrigens immer noch nicht.

Ich weiss auch nicht warum der gehängt hat, ich habe aber ein neues 
Programm erstellt und jetzt klappts.

[Christopher J. (christopher_j23)]

Bert S. schrieb:
> ADC_MultiModeTypeDef multimode;

Bert S. schrieb:
> multimode.Mode = ADC_DUALMODE_REGSIMULT;
>   multimode.DMAAccessMode = ADC_DMAACCESSMODE_12_10_BITS;
>   multimode.TwoSamplingDelay = ADC_TWOSAMPLINGDELAY_1CYCLE;
>   if (HAL_ADCEx_MultiModeConfigChannel(&hadc1, &multimode) != HAL_OK)
>   {
>     _Error_Handler(_FILE_, _LINE_);
>   }

Die entsprechende Zeile hatte ich dir sogar vorher schon markiert. Hast 
du eigentlich jemals in den Quelltext der HAL-Funktionen bzw. ins 
User-Manual geschaut? Das würde ich an deiner Stelle mal machen.