STM32F4 USART DMA-Transmit Probleme

[herakles (Gast)]

Moin!

Ich möchte gern über die USART1 eines STM32F4 Cortex-M4 Prozessors Daten 
senden. Das klappt auch wunderbar mit folgendem Code:

void configure_clocks( void ) {
  // Enable peripheral clock. USART2 liegt auf APB1 ( Handbuch, Tabelle 5,
  // "USART feature comparison" auf Seite 34
  //RCC_APB1PeriphClockCmd( B03_USART_DISPLAY_CLK, ENABLE );
  RCC_APB2PeriphClockCmd( RCC_APB2Periph_USART1, ENABLE );
  // Enable the GPIO clocks. Die USART2-Funktionen liegen allesamt auf GPIO port A.
  // Handbuch Seite 60
  RCC_AHB1PeriphClockCmd( RCC_AHB1Periph_GPIOB, ENABLE );
}

void init_usart( void ) {
  GPIO_InitTypeDef GPIO_InitStructure;
  USART_InitTypeDef USART_InitStructure;
  
  memset( &GPIO_InitStructure, 0, sizeof(GPIO_InitTypeDef) );
  memset( &USART_InitStructure, 0, sizeof(USART_InitTypeDef) );
  // Connect the pin to the desired peripherals' alternate function.
  // Wiederrum GPIOA, die TX-Source ist GPIO_PinSource2 und die alternate
  // Function ist die 7(und GPIO_AF_USART2 löst sich zu 0x07 auf) - laut Tabelle Seite 60.
  GPIO_PinAFConfig( GPIOB, GPIO_PinSource6, GPIO_AF_USART1 );
  GPIO_PinAFConfig( GPIOB, GPIO_PinSource7, GPIO_AF_USART1 );
  memset( &GPIO_InitStructure, 0, sizeof(GPIO_InitTypeDef) );
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init( GPIOB, &GPIO_InitStructure );

  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
  GPIO_Init( GPIOB, &GPIO_InitStructure );
  // Configure USART
  memset( &USART_InitStructure, 0, sizeof(USART_InitTypeDef) );
  USART_InitStructure.USART_BaudRate = 115200;
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  USART_InitStructure.USART_StopBits = USART_StopBits_1;
  USART_InitStructure.USART_Parity = USART_Parity_No;
  USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  USART_Init( USART1, &USART_InitStructure );
      // Enable the USART
  USART_Cmd( USART1, ENABLE );
}

int main() {
  configure_clocks();
  init_usart();
  
  uint8_t daten = 0xdb;
  USART_SendData(USART1, daten);
        while(1);
}

Nun möchte ich das aber gern mit einem DMA lösen, damit die CPU andere 
Dinge machen darf, während die USART Daten schreibt. Dafür habe ich nach 
intensivem Wühlen im Internet - darunter auch zahlreiche Seite von 
diesem erstklassigen Forum - keine wirkliche Lösung gefunden, sprich: 
Ich sehe keine Daten auf der Schnittstelle.

Hier meine Codelösung für eine Datenübertragung mit DMA-Zugriff:

unsigned char buffer[9] = {0x11,0x06,0x23,0x4d,0x4e,0x32,0x2c,0x0a,0x3d};

void configure_clocks( void ) {
  RCC_AHB1PeriphResetCmd(RCC_AHB1Periph_DMA2, ENABLE);
  // Enable peripheral clock. USART2 liegt auf APB1 ( Handbuch, Tabelle 5,
  // "USART feature comparison" auf Seite 34
  //RCC_APB1PeriphClockCmd( B03_USART_DISPLAY_CLK, ENABLE );
  RCC_APB2PeriphClockCmd( RCC_APB2Periph_USART1, ENABLE );
  // Enable the GPIO clocks. Die USART2-Funktionen liegen allesamt auf GPIO port A.
  // Handbuch Seite 60
  RCC_AHB1PeriphClockCmd( RCC_AHB1Periph_GPIOB, ENABLE );
}

void init_usart( void ) {
  GPIO_InitTypeDef GPIO_InitStructure;
  USART_InitTypeDef USART_InitStructure;
  
  memset( &GPIO_InitStructure, 0, sizeof(GPIO_InitTypeDef) );
  memset( &USART_InitStructure, 0, sizeof(USART_InitTypeDef) );
  // Connect the pin to the desired peripherals' alternate function.
  // Wiederrum GPIOA, die TX-Source ist GPIO_PinSource2 und die alternate
  // Function ist die 7(und GPIO_AF_USART2 löst sich zu 0x07 auf) - laut Tabelle Seite 60.
  GPIO_PinAFConfig( GPIOB, GPIO_PinSource6, GPIO_AF_USART1 );
  GPIO_PinAFConfig( GPIOB, GPIO_PinSource7, GPIO_AF_USART1 );
  memset( &GPIO_InitStructure, 0, sizeof(GPIO_InitTypeDef) );
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init( GPIOB, &GPIO_InitStructure );

  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
  GPIO_Init( GPIOB, &GPIO_InitStructure );
  // Configure USART
  memset( &USART_InitStructure, 0, sizeof(USART_InitTypeDef) );
  USART_InitStructure.USART_BaudRate = 115200;
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  USART_InitStructure.USART_StopBits = USART_StopBits_1;
  USART_InitStructure.USART_Parity = USART_Parity_No;
  USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  USART_Init( USART1, &USART_InitStructure );
}

void DMAStream7_Channel4_Init(void) {
  DMA_InitTypeDef DMA_InitStruct;

  /* USART1_TX DMA2 Channel 7 */
  
  DMA_DeInit(DMA2_Stream7);
  
  DMA_StructInit(&DMA_InitStruct);
    DMA_InitStruct.DMA_Channel = DMA_Channel_4;
  DMA_InitStruct.DMA_PeripheralBaseAddr = (uint32_t)&(USART1->DR);
  DMA_InitStruct.DMA_Memory0BaseAddr = (uint32_t)buffer;
  DMA_InitStruct.DMA_DIR = DMA_DIR_MemoryToPeripheral;
  DMA_InitStruct.DMA_BufferSize = 9;
  DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;
  DMA_InitStruct.DMA_PeripheralDataSize = DMA_MemoryDataSize_Byte;
  DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
  DMA_InitStruct.DMA_Mode = DMA_Mode_Normal;
  DMA_InitStruct.DMA_Priority = DMA_Priority_Medium;
  
//  6a. Configure the DMA using DMA_Init() function
  DMA_Init(DMA2_Stream7, &DMA_InitStruct);

//  6b.Active the needed channel Request using USART_DMACmd() function
  USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);
//  7. Enable the USART using the USART_Cmd() function.
  USART_Cmd( USART1, ENABLE );
  
  DMA_Cmd(DMA2_Stream7, ENABLE);
}

int main() {
  configure_clocks();
  init_usart();
  DMAStream7_Channel4_Init();
  while(1);
}

Mit dem ersten Codebeispiel sehe ich mit einem Terminalprogramm auf der 
Schnittstelle ein hexadezimales "0xDB", was mir zeigt, dass 
hardwaremäßig alles funktioniert. Demzufolge sollte also mit 
entsprechender Initilisierung auch ein DMA-Transfer über die 
Schnittstelle funktionieren. Das ist aber nicht der Fall.

Sieht jemand, welchen Fehler ich gemacht haben könnte? Ich brüte nun 
wirklich seit Stunden, bekomme aber kein Byte aus der Schnittstelle über 
DMA gequescht.

Vielen Dank für jeden Tipp im Voraus,
Herakles

[Markus R. (maggus)]

> DMA_InitStruct.DMA_PeripheralDataSize = DMA_MemoryDataSize_Byte;

müsste eigentlich

> DMA_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;

sein, sollte hier aber egal sein (da beides 0x00 ist).

Hier hat es schon jemand mit der DMA1 zum laufen bekommen:
Beitrag "STM32 F4 Discovery USART mit DMA"

[(prx) A. K. (prx)]

Du solltest genug Takt aufbringen, auch den DMA Controller damit zu 
versorgen. Vielleicht statt RCC_AHB1PeriphResetCmd.

[iwasz (Gast)]

Hi, I don't know if your problem is resolved or not, because I don't 
speak German, and since I've translated this page from German to English 
with Google, not everything is clear to me here. I had the same issue, 
and spent 2 nights on this (fu.k!), and solution was really simple and 
stupid : change

 RCC_AHB1PeriphResetCmd(RCC_AHB1Periph_DMA2, ENABLE);

to

 RCC_APB2PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE);

You probably followed documentation in stm32f4xx_dma.c, which in very 
first paragraph says to use RCC_AHB1PeriphResetCmd. So did I, but in my 
opinion this is a mistake on their (ST) part.

Regs.
iwasz.pl