STM32: Umsetzung der UART im DMA-Modus

Wenn Sie den DMA-dann haben Sie zwei interrupts: wenn die Hälfte von dem Puffer übertragen wird und ein weiteres, wenn die zweite Hälfte übertragen wird (insgesamt).

Beide gefeuert werden sollte wenn alles OK ist. Der Grund dafür ist, dass beim senden einer großen Menge von Daten, können Sie beginnen laden von neuen Daten in der ersten Hälfte des Puffers in die TxHalfCpltCallback während der zweiten Hälfte des Puffers übertragen wird, die von der DMA. Und, können Sie wieder laden Sie die neuen Daten in der zweiten Hälfte des Puffers in die TxCpltCallback während die erste Hälfte übertragen wird.

Der Vorteil ist, dass Sie brauchen nicht zu warten, für die gesamte übertragung abgeschlossen ist, bevor Sie kopieren das nächste Stück von Daten in den Puffer, aber du kannst schon starten, laden Sie es, während die übertragung noch im Gange ist.

Hier ein Beispiel:

In diesem Beispiel 2000 bytes, die übertragen werden mit DMA, Übermitteln Hälfte Komplett und Übermitteln Komplette unterbricht die Erreichung der besten Leistung.

Der ersten Hälfte der sende-buffer ist voll mit neuen Daten von der CPU in den Übermitteln Hälfte Komplett interrupt callback, während der zweiten Hälfte des Puffers übertragen wird, durch den DMA im hintergrund.

Dann, in der Übermitteln Komplette der zweiten Hälfte der sende-Puffer geladen wird, indem die neuen Daten von der CPU, während der ersten Hälfte des (bereits aktualisiert) übertragen wird, durch den DMA im hintergrund.

#include "stm32f4xx.h"

uint8_t dma_buffer[2000];
volatile uint8_t toggle = 0;

UART_HandleTypeDef huart2;
DMA_HandleTypeDef hdma_usart2_tx;

void uart_gpio_init()
{
  GPIO_InitTypeDef GPIO_InitStruct;

  __GPIOA_CLK_ENABLE();

  /**USART2 GPIO Configuration
  PA2     ------> USART2_TX
  PA3     ------> USART2_RX
  */
  GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_3;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF7_USART2;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
}

void uart_dma_init()
{
  /* DMA controller clock enable */
  __DMA1_CLK_ENABLE();

  /* Peripheral DMA init*/
  hdma_usart2_tx.Instance = DMA1_Stream6;
  hdma_usart2_tx.Init.Channel = DMA_CHANNEL_4;
  hdma_usart2_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
  hdma_usart2_tx.Init.PeriphInc = DMA_PINC_DISABLE;
  hdma_usart2_tx.Init.MemInc = DMA_MINC_ENABLE;
  hdma_usart2_tx.Init.PeriphDataAlignment = DMA_MDATAALIGN_BYTE;
  hdma_usart2_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
  hdma_usart2_tx.Init.Mode = DMA_NORMAL;
  hdma_usart2_tx.Init.Priority = DMA_PRIORITY_LOW;
  hdma_usart2_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
  HAL_DMA_Init(&hdma_usart2_tx);

  __HAL_LINKDMA(&huart2,hdmatx,hdma_usart2_tx);

  /* DMA interrupt init */
  HAL_NVIC_SetPriority(DMA1_Stream6_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Stream6_IRQn);
}

void uart_init()
{
  __USART2_CLK_ENABLE();

  huart2.Instance = USART2;
  huart2.Init.BaudRate = 115200;
  huart2.Init.WordLength = UART_WORDLENGTH_8B;
  huart2.Init.StopBits = UART_STOPBITS_1;
  huart2.Init.Parity = UART_PARITY_NONE;
  huart2.Init.Mode = UART_MODE_TX_RX;
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  HAL_UART_Init(&huart2);

  /* Peripheral interrupt init*/
  HAL_NVIC_SetPriority(USART2_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(USART2_IRQn);
}

/* This function handles DMA1 stream6 global interrupt. */
void DMA1_Stream6_IRQHandler(void)
{
  HAL_DMA_IRQHandler(&hdma_usart2_tx);
}

void USART2_IRQHandler(void)
{
  HAL_UART_IRQHandler(&huart2);
}

void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
  uint16_t i;
  toggle = !toggle;

  for(i = 1000; i < 1998; i++)
  {
    if(toggle)
      dma_buffer[i] = '&';
    else
      dma_buffer[i] = 'z';
  }

  dma_buffer[1998] = '\r';
  dma_buffer[1999] = '\n';
}

void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart)
{
  uint16_t i;

  for(i = 0; i < 1000; i++)
  {
    if(toggle)
      dma_buffer[i] = 'y';
    else
      dma_buffer[i] = '|';
  }
}

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

  uart_gpio_init();
  uart_dma_init();
  uart_init();

  uint16_t i;

  for(i = 0; i < 1998; i++)
  {
    dma_buffer[i] = 'x';
  }

  dma_buffer[1998] = '\r';
  dma_buffer[1999] = '\n';

  while(1)
  {
    HAL_UART_Transmit_DMA(&huart2, dma_buffer, 2000);
  }
}

Beispiel wurde geschrieben für ein STM32F4 Discovery-board (STM32F407VG). Die entsprechenden DMA-Instanz, UART-DMA-Kanal, GPIO-und alternate-Funktion Einstellungen geändert werden sollen, nach der STM32-mikrocontroller im Einsatz.

InformationsquelleAutor Bence Kaulics

Wenn Sie die Funktion

HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size) 

in der CubeMX Bibliothek, die es ermöglichen, werden alle DMA-interrupts. Sie können deaktivieren Sie die Hälfte die übertragung unterbrechen, die von den clearing-HTIE-bit in der DMA_SxCR registrieren.

InformationsquelleAutor Jackson

Ist es viel einfacher, code DMA-übertragung (und bekommen natürlich), wenn Sie die nackten register Ansatz, anstelle der Moloch HAL-monster.

Beispiel STM32F446 (vorausgesetzt, reset-Werte in den Registern)

DMA1_Stream6 -> NDTR = nTransfers;
DMA1_Stream6 -> PAR = (uint32_t)&(USART2 -> DR);
DMA1_Stream6 -> M0AR = (uint32_t)&dataBuff;
DMA1_Stream6 -> CR = DMA_SxCR_CHSEL_2 | DMA_SxCR_MINC | DMA_SxCR_DIR_0 | DMA_SxCR_TCIE; //you can enable half transfer enable as well

USART2 -> BRR = FCLK /LOWSPEED;
USART2 -> CR3 |= USART_CR3_DMAT;
USART2 -> CR1 = (USART_CR1_TE | USART_CR1_RE | USART_CR1_UE);
DMA1_Stream6 -> CR |= DMA_SxCR_EN;

ganz einfach - oder doch nicht?

void DMA1_Stream6_IRQHandler(void) {  //now it does nothing only clears the flag
    if(DMA1 -> HISR & (DMA_HISR_TCIF6)) {
        DMA1 -> HIFCR |= DMA_HISR_TCIF6;
        while(!(USART2 -> SR & USART_SR_TC));
    }
}

InformationsquelleAutor P__J__