STM32 F4 Discovery USART mit DMA

[Sergej E. (esergej)]

Hallo
Bin grade dabei  sich in die Programmierung des ARM Mikrocontrollers 
einzuarbeiten. Benutze  STM32 F4 discovery  Board und Keil µVision4. Hab 
jetzt aber Schwierigkeiten die USART Schnittstelle mit DMA zum Laufen zu 
bringen  (mit Interrupts und ohne DMA hat es schon funktioniert). Und 
zwar sehe ich mit dem Oszilloskop das es irgendwelche  Daten verschickt 
werden 1.6 Sekunden nach dem Start bricht die Übertragung aber ab und 
Transfer Error Interrupt Flag kommt. Dies Pasier in Circular mode  sowie 
bei nur einmaliger Übertragung.  Ich verschicke aber nur 8 Byte  mir 2 
Stopbits die sollte bei einmaliger Übertragung nur  0,954ms dauern. 
Schalte ich Memory Inkrementierung ab so wird nur der erste Byte dauernd 
ohne Unterbrechung übertragen, aber dann auch wen Circular mode 
ausgeschaltet wird was eigentlich nicht sein dürfte. Und wenn ich es 
anhalte und im NDTR Register den Wert nachschaue dann hat es auch einen 
Wert den er gar nicht erreichen sollte. Kann da vielleicht jemand meinen 
Code  anschauen vielleicht sieht da jemand mein Fehler.

#include "stm32f4xx.h"
#include "stm32f4xx_conf.h"

int main(void){  
  uint32_t Warteschleife = 0;  
  unsigned char USART_String[8];   
   
  USART_String[0] = 170;
  USART_String[1] = 240;
  USART_String[2] = 40;
  USART_String[3] = 230;
  USART_String[4] = 50;
  USART_String[5] = 220;
  USART_String[6] = 60;
  USART_String[7] = 210;

  RCC->CFGR &= ~2;
  RCC->CR &= ~RCC_CR_PLLON;    
  RCC->PLLCFGR &= ~0xFFFFFFFF;
  RCC->PLLCFGR |= 16 << 0;     // 16 PLLM  Teiler für 163 MHz
  RCC->PLLCFGR |= 336 << 6;     // 336 PLLN  Multiplikator für 168 MHz
  RCC->CR |= RCC_CR_PLLON;   
  RCC->CFGR = RCC_CFGR_PPRE2_DIV2 | RCC_CFGR_PPRE1_DIV4 | RCC_CFGR_SW_PLL; 
  RCC->AHB1ENR |= RCC_AHB1ENR_GPIOCEN | RCC_AHB1ENR_DMA2EN;    
  RCC->APB2ENR |= RCC_APB2ENR_USART6EN;  
    
  GPIOC->MODER |= GPIO_Mode_AF << 14| GPIO_Mode_AF << 12;
  GPIOC->OSPEEDR |= GPIO_Speed_100MHz << 14 | GPIO_Speed_100MHz << 12;
  GPIOC->PUPDR |= GPIO_PuPd_UP << 14 | GPIO_PuPd_UP << 12; 
  GPIOC->AFR[0] |= GPIO_AF_USART6 << 24 | GPIO_AF_USART6 << 28;     

  USART6->CR1 = USART_CR1_OVER8 | USART_Mode_Tx | USART_Mode_Rx; 
  USART6->BRR = 11 << 4 | 7 << 0;  
  USART6->CR2 = USART_StopBits_2;    
  USART6->CR3 = USART_DMAReq_Tx ;
  USART6->CR1 |= USART_CR1_UE;

  DMA2_Stream7->CR = DMA_Channel_5 | DMA_MemoryInc_Enable 
                    | DMA_DIR_MemoryToPeripheral | DMA_FlowCtrl_Peripheral;
  DMA2_Stream7->NDTR = 8;
  DMA2_Stream7->PAR = (uint32_t)&USART6->DR;
  DMA2_Stream7->M0AR = (uint32_t)&USART_String;            
  DMA2_Stream7->FCR |= DMA_FIFOMode_Enable | DMA_FIFOThreshold_Full;
  DMA2_Stream7->CR |= DMA_Mode_Circular;
  DMA2_Stream7->CR |= DMA_SxCR_EN;
          
  while(1){
     while(Warteschleife < 10000){
        Warteschleife++;
     }
     Warteschleife=0;    
  }
}

[Sergej E. (esergej)]

Hat keiner eine Idee?

[Matthias K. (matthiask)]

Was hat es mit der Warteschleife auf sich?

[Sergej E. (esergej)]

Gar nichts ist eine endlosschleife kann  man eigentlich entfernen. Ist 
noch davon übrig geblieben als ich versucht hatte die Daten ohne 
Circular Modus zu verschicken  im zeitabstand dieser Warteschleife.

[David Hediger (Gast)]

Unkommentierten Code zu lesen macht leider nicht besonders an. Kannst du 
im Code beschreiben, was du ungefähr machst?

PS: Ich wäre auch sehr interessiert an einer DMA-Lösung für die UART.

[Tomasz M. (tomasz_m)]

Hi,

I had the same problem. I worked without DMA_Mode_Circular and without 
DMA_FIFOMode_Enable. It should just send 8 characters and STOP !

I suspect it may have something to do with DMA_FlowCtrl_Peripheral.
I have just tested - it goes better without DMA_FlowCtrl_Peripheral.

Then I had next problem - I could not  pause it - it did not restart 
after re-enabling.

dmastr->CR &= ~DMA_SxCR_EN;
for(i = 0; i < 0x800; i++);
dmastr->CR |= DMA_SxCR_EN;
// DMA does not continue

I had to clear TCIF flag in *IFCR register before DMA_SxCR_EN

--
Tomasz Motylewski
K&J Schmittschneider AG

[Moritz M. (avrprogger)]

Hallo,

also unter Atollic TrueStudio funktioniert es so:

#include "stm32f4xx.h"


void USART3_Init(void);
void DMAStream3_Channel4_Init();

unsigned char buffer[129] = "Hello World, this is a DMA test. If you can read this the DMA is still working!\n";

int main(void)
{
  USART3_Init();
  DMAStream3_Channel4_Init();
  USART_DMACmd(USART3, USART_DMAReq_Tx, ENABLE);
  DMA_Cmd(DMA1_Stream3, ENABLE);
  while(1);
}

void USART3_Init(void)
{
  GPIO_InitTypeDef GPIOC_10_11_InitStructure;
  USART_InitTypeDef USART3_InitStructure;

  //GPIO C 10/11 Init
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

  GPIO_PinAFConfig(GPIOC, GPIO_PinSource10, GPIO_AF_USART3);
  GPIO_PinAFConfig(GPIOC, GPIO_PinSource11, GPIO_AF_USART3);

  GPIOC_10_11_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIOC_10_11_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIOC_10_11_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11;
  GPIOC_10_11_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  GPIOC_10_11_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

  GPIO_Init(GPIOC, &GPIOC_10_11_InitStructure);

  //USART 3 Init
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);

  USART3_InitStructure.USART_BaudRate = 9600;
  USART3_InitStructure.USART_WordLength = USART_WordLength_8b;
  USART3_InitStructure.USART_StopBits = USART_StopBits_1;
  USART3_InitStructure.USART_Parity = USART_Parity_No;
  USART3_InitStructure.USART_HardwareFlowControl =
USART_HardwareFlowControl_None;
  USART3_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;

  USART_Init(USART3, &USART3_InitStructure);
  USART_Cmd(USART3, ENABLE);
}
void DMAStream3_Channel4_Init(void)
{
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);

  DMA_InitTypeDef DMA_InitStruct;
  DMA_StructInit(&DMA_InitStruct);
  DMA_InitStruct.DMA_Channel = DMA_Channel_4;
  DMA_InitStruct.DMA_PeripheralBaseAddr = (uint32_t)&(USART3->DR);
  DMA_InitStruct.DMA_Memory0BaseAddr = (uint32_t)&buffer;
  DMA_InitStruct.DMA_DIR = DMA_DIR_MemoryToPeripheral;
  DMA_InitStruct.DMA_BufferSize = 129;
  DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;
  DMA_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
  DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
  DMA_InitStruct.DMA_Mode = DMA_Mode_Circular;
  DMA_InitStruct.DMA_Priority = DMA_Priority_Medium;
  DMA_InitStruct.DMA_FIFOMode = DMA_FIFOMode_Disable;
  DMA_InitStruct.DMA_FIFOThreshold = DMA_FIFOThreshold_HalfFull;
  DMA_InitStruct.DMA_MemoryBurst = DMA_MemoryBurst_Single;
  DMA_InitStruct.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
  DMA_Init(DMA1_Stream3, &DMA_InitStruct);
}

[Dimitri M. (dimitri)]

In Keil finzt es ebenfalls. Mein Dank geht an Moritz :)

[W.S. (Gast)]

Sergej E. schrieb:
> Hab jetzt aber Schwierigkeiten die USART Schnittstelle mit DMA zum Laufen zu 
bringen

Wozu eigentlich?
Gerade der USART ist - wenn man ihn für gewöhnliche Zwecke gebraucht - 
eher etwas für einen gemütlichen Interrupt-Betrieb mit softwareseitigem 
Ringpuffer als für DMA. Schau doch nur, was du selbst in deinem Beispiel 
für Aufwand treiben mußt, um die DMA überhaupt nur erstmal anzulassen.

Kurz gesagt, ich würde den USART eher nicht per DMA betreiben wollen, 
es macht mehr Probleme als es nützt.

W.S.

[Moritz M. (avrprogger)]

Hallo,

ja aber wenn man Datenmengen vom mehreren hundert KB dauernd übertragen 
muss ist es denke ich schon sinnvoll nicht die ganze Zeit die CPU zu 
blockieren. Das das so viel Code ist liegt nicht an der DMA sondern ehr 
an der Lib und dem µC, wobei die Lib schon eine sehr große hilfe ist, um 
nicht alle Register einzeln setzen zu müssen.

Moritz

[Tobias S. (tryan)]

Hallo,
ich bin auch grade dabei Mir USART und DMA zu experimentieren.

Dank dem Quellcode von Moritz M. (Umgeschireben auf USART2) funktioniert 
die Übertragung schon gut außer es werden noch viele "Nullen" 
mitgeschickt, aber das ist ein anderes Thema.

Leider werden die Daten permanent geschickt. Wie deaktiviere ich das DMA 
nach einer Übertragung am besten? Bzw. wie erkläre ich dem DMA das der 
String zu Ende ist und die Übertragung abgeschlossen ist und ich das DMA 
wieder Deaktivieren kann.

Viele grüße Tobias

[Moritz M. (moritz_m72)]

Hallo,

ich schätze DMA_Mode ändern. Sieh doch mal in der dma.c nach.

Moritz M.

[Moritz M. (moritz_m72)]

Hallo nochmal,

DMA_Mode = DMA_Mode_Normal;

Beschreibung der einzelnen Parameter sind in der dma.h

Moritz M.