STM32F4 DMA Request und IRQ Handler

[Aljo E. (alrue)]

Hallo,
ich möchte den ADC3 mit dem DMA2_Stream1_Channel2 benutzen. Der ADC wird 
vom TIM3 getriggert. Sobald der Transfer in den DMA komplett ist, soll 
der DMA2_Stream1_IRQHandler aufgerufen werden. Dort möchte ich prüfen ob 
das Transer complete flag gesetzt wird.

Es tritt nun der Fall auf, dass ich sofort nach Programmbeginn in den 
DMA2_Stream1_IRQHandler gelange und dort im Prinzip nicht mehr 
rauskomme. Ich habe zum Testzweck eine LED getoggelt, jedes mal wenn die 
der IRQHandler aufgerufen wird und habe festgestellt, dass der mit 781 
kHz aufgerufen wird. Der Timer und die ADC Clock haben keinerlei 
Einfluss auf diesen absurd häufigen andlerzugriff. Eigentlich sollte 
doch alle paar Sekunden (je nach Einstellung des Timers) der ADC 
getriggert werden, die Wert vom ADC werden in den DMA geschrieben und 
dann komme ich in den Handler und sehe, dass das TF Flag gesetzt ist und 
mache dort meine Sachen. Allerdings ist auch nicht das TF Flag gesetzt 
und ich lande trotzdem im Handler.

Ich bin sehr verwirrt und würde mich über ein wenig Aufklärung freuen!

#define SCANBUFFERSIZE 1024
__IO uint16_t ADCScanConvVal[SCANBUFFERSIZE];
__IO uint8_t DMA2_Stream1_TC_Flg;

void RCC_Configuration(void)
{
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE);
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC2, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC3, ENABLE);
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
}

void ADCscan_Configuration(void) // DMA2_Stream1_Channel2 für ADC3
{
  ADC_CommonInitTypeDef ADC_CommonInitStructure;
  ADC_InitTypeDef ADC_InitStructure;

  ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent;
  ADC_CommonInitStructure.ADC_Prescaler = ADC_Prescaler_Div2;
  ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled;
  ADC_CommonInitStructure.ADC_TwoSamplingDelay = ADC_TwoSamplingDelay_5Cycles;
  ADC_CommonInit(&ADC_CommonInitStructure);

  ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
  ADC_InitStructure.ADC_ScanConvMode = DISABLE;
  ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
  ADC_InitStructure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_Rising;
  ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T3_TRGO;
  ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
  ADC_InitStructure.ADC_NbrOfConversion = 1;
  ADC_Init(ADC3, &ADC_InitStructure);

  ADC_RegularChannelConfig(ADC3, ADC_Channel_10, 1, ADC_SampleTime_15Cycles); // PC0
  //ADC_RegularChannelConfig(ADC3, ADC_Channel_11, 2, ADC_SampleTime_15Cycles); // PC1
  //ADC_RegularChannelConfig(ADC3, ADC_Channel_12, 3, ADC_SampleTime_15Cycles); // PC2
  //ADC_RegularChannelConfig(ADC3, ADC_Channel_13, 4, ADC_SampleTime_15Cycles); // PC3

  ADC_DMARequestAfterLastTransferCmd(ADC3, ENABLE);
  ADC_DMACmd(ADC3, ENABLE);
  ADC_Cmd(ADC3, ENABLE);
}

static void DMA2_Stream1_Configuration(void)
{
  DMA_InitTypeDef DMA_InitStructure;

  DMA_InitStructure.DMA_Channel = DMA_Channel_2;
  DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)&ADCScanConvVal;
  DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t) 0x4001224C;//&ADC3->DR //ADC_CCR_ADDRESS
  DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
  DMA_InitStructure.DMA_BufferSize = SCANBUFFERSIZE;
  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_Circular;
  DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
  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_Stream1, &DMA_InitStructure);

  DMA_ITConfig(DMA2_Stream1, DMA_IT_TC, ENABLE);

  DMA_Cmd(DMA2_Stream1, ENABLE);
}

void TIM3_Configuration(void)
{
  TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;

  TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
  TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV4;
  TIM_TimeBaseStructure.TIM_Period = 840;
  TIM_TimeBaseStructure.TIM_Prescaler = 50000;
  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);

  TIM_SelectOutputTrigger(TIM3, TIM_TRGOSource_Update);

  TIM_Cmd(TIM3, ENABLE);
}

void NVIC_Configuration(void)
{
  NVIC_InitTypeDef NVIC_InitStructure2;

  NVIC_InitStructure2.NVIC_IRQChannel = DMA2_Stream1_IRQn;
  NVIC_InitStructure2.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure2.NVIC_IRQChannelSubPriority = 0;
  NVIC_InitStructure2.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure2);
}

void DMA2_Stream1_IRQHandler(void)
{
  GPIO_ToggleBits(GPIOA, GPIO_Pin_5);
  if(DMA_GetITStatus(DMA2_Stream1, DMA_IT_TCIF0) || DMA_GetITStatus(DMA2_Stream1, DMA_IT_HTIF0))
  {
    DMA_ClearITPendingBit(DMA2_Stream1, DMA_IT_TCIF0);
    DMA_ClearITPendingBit(DMA2_Stream1, DMA_IT_HTIF0);

    //GPIO_ToggleBits(GPIOA, GPIO_Pin_5);

    DMA2_Stream1_TC_Flg = 1;

    ADC_Cmd(ADC3, DISABLE);
  }
}

int main(void)
{
    clock_Configuration();
    SystemCoreClockUpdate();

  RCC_Configuration();
  GPIO_Configuration();
  NVIC_Configuration();
  TIM3_Configuration();
  DMA2_Stream1_Configuration();
  ADCscan_Configuration();
  USART_Configuration();
  SPI_Configuration();

  ADC_SoftwareStartConv(ADC3);

  while(1)
  {

    if(DMA2_Stream1_TC_Flg == 1)
    {
      copyData();
      conversionRestart();
      sendData();
    }

  }
}

[Nico W. (nico_w)]

Ich arbeite zwar direkt mit den Registern, aber ich hatte am Anfang auch 
ganz schön zu kämpfen.

Im DMA-Handler checke ich den TCIF, clear das Flag und deaktiviere den 
Continious Mode vom ADC.

Im Timer (bei mir zumindest sowas ähnliches), starte ich dann den ADC 
neu und aktiviere wieder den Cont-Mode vom ADC. Den kompletten ADC 
braucht man ja nicht deaktiveren.

Musst sonst mal gucken was der ADC_cmd(xx, DISABLE) alles noch macht.

Also ganz grob als ADC-Init:
CR1_SCAN
CR2_DMA
CR2_DDS
CR2_CONT
CR2_ADON
CR2_SWSTART

Im DMA-Init:
CR_TCIE
CR_EN

Im DMA-Handler
if TCIF
DMA->HIFCR clear
ADC->CR2 &= ~CR2_CONT

Im Timer:
ADC->CR2 |= CR2_SWSTART | CR2_CONT

[Aljo E. (alrue)]

Also das Problem scheint bei mir der DMA2_Stream 1 zu sein. Ich habe 
eine Version wie ich sie brauche zum laufen gebracht, allerdings mit dem 
DMA2_Stream0_Channel2 (ist dem ADC3 zugeordnet). Hat super funktioniert. 
Anschließend habe ich einfach auf den DMA2_Stream1_Channel2, welcher 
laut AN4031 ebenfalls ADC3 zugeordnet ist. Dann funktioniert der Code 
aber nicht mehr und der Prozessor kommt nicht in meinen 
DMA2_Stream1_IRQHandler.

Was könnte das Problem sein? Muss ich einen anderen ADC channel 
verwenden? Ich hab keine Ahnung.