![\"\"](\"https:\/\/visualgdb.com\/w\/wp-content\/uploads\/2019\/06\/01-newprj-5.png\")
<\/a><\/li>\n<\/a><\/li>\n<\/a><\/li>\n<\/a><\/li>\n<\/a><\/li>\n<\/a><\/li>\n<\/a>Warning: Ensure you enable the Chronometer for both Debug and Release configurations, as we will be using both of them in this tutorial.<\/strong><\/li>\n- \n
- Fill a memory buffer with a sequence of numbers: Ni<\/sub> = i * 3.<\/li>\n
- Copy the contents of the buffer to another buffer.<\/li>\n
- Fill the third buffer with the first 1024 Fibonacci numbers.<\/a><\/li>\n<\/ul>\n
Then we will and will then show how using the DMA improves its performance. Replace the main() function in your project with the following code:<\/p>\n
#include <memory.h>\r\n\r\nstatic int s_Buffer1[1024], s_Buffer2[1024], s_Buffer3[1024];\r\n\r\n#define ARRAY_SIZE(x) (sizeof(x) \/ sizeof((x)[0]))\r\n\r\nvoid __attribute__((noinline)) FillMemory()\r\n{\r\n for (int i = 0; i < ARRAY_SIZE(s_Buffer1); i++)\r\n s_Buffer1[i] = i * 3;\r\n}\r\n\r\nvoid __attribute__((noinline)) CopyMemory()\r\n{\r\n memcpy(s_Buffer2, s_Buffer1, sizeof(s_Buffer2));\r\n}\r\n\r\nvoid __attribute__((noinline)) CalculateFibonacci()\r\n{\r\n s_Buffer3[0] = 0;\r\n s_Buffer3[1] = 1;\r\n\r\n for (int i = 2; i < ARRAY_SIZE(s_Buffer3); i++)\r\n {\r\n s_Buffer3[i] = s_Buffer3[i - 1] + s_Buffer3[i - 2];\r\n }\r\n}\r\n\r\nint main(void)\r\n{\r\n HAL_Init();\r\n\r\n FillMemory();\r\n CopyMemory();\r\n CalculateFibonacci();\r\n\r\n volatile int x = s_Buffer2[4];\r\n}\r\n<\/pre>\n<\/li>\n- To minimize the impact of unoptimized code on the measured numbers, switch the active configuration to Release, then set a breakpoint at the call to FillMemory() and start debugging:
![\"\"](\"https:\/\/visualgdb.com\/w\/wp-content\/uploads\/2019\/06\/08-step1.png\")
<\/a><\/li>\n- Once the breakpoint hits, step over the FillMemory()<\/strong>, CopyMemory()<\/strong> and CalculateFibonacci()<\/strong> calls and check the Chronometer window for the timings:
![\"\"](\"https:\/\/visualgdb.com\/w\/wp-content\/uploads\/2019\/06\/09-timings.png\")
<\/a>In this example, filling the first and the third buffer took the exactly the same time, while copying the first buffer to the second one took slightly less time:![\"\"](\"https:\/\/visualgdb.com\/w\/wp-content\/uploads\/2019\/06\/timing1.png\")
<\/a><\/li>\n- While the DMA cannot be used to compute Fibonacci numbers, or initialize arrays with non-constant values, it can be used for copying data between 2 memory locations. We will now demonstrate this by replacing the CopyMemory()<\/strong> function with the following one:\n
#include <stm32f4xx_hal_dma.h>\r\n\r\nstatic DMA_HandleTypeDef s_DMAHandle;\r\n\r\nvoid __attribute__((noinline)) CopyMemoryWithDMA()\r\n{\r\n s_DMAHandle.Instance = DMA2_Stream0;\r\n s_DMAHandle.Init.Channel = DMA_CHANNEL_0;\r\n\r\n s_DMAHandle.Init.Direction = DMA_MEMORY_TO_MEMORY;\r\n s_DMAHandle.Init.PeriphInc = DMA_PINC_ENABLE;\r\n s_DMAHandle.Init.MemInc = DMA_MINC_ENABLE;\r\n s_DMAHandle.Init.Mode = DMA_NORMAL;\r\n s_DMAHandle.Init.Priority = DMA_PRIORITY_VERY_HIGH;\r\n\r\n s_DMAHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;\r\n s_DMAHandle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;\r\n\r\n s_DMAHandle.Init.FIFOMode = DMA_FIFOMODE_ENABLE;\r\n s_DMAHandle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL;\r\n\r\n __DMA2_CLK_ENABLE();\r\n\r\n HAL_StatusTypeDef status = HAL_DMA_Init(&s_DMAHandle);\r\n if (status != HAL_OK)\r\n asm(\"bkpt 255\");\r\n\r\n status = HAL_DMA_Start(&s_DMAHandle, (uint32_t)s_Buffer1, (uint32_t)s_Buffer2, sizeof(s_Buffer1) \/ sizeof(s_Buffer1[0]));\r\n if (status != HAL_OK)\r\n asm(\"bkpt 255\");\r\n\r\n HAL_DMA_PollForTransfer(&s_DMAHandle, HAL_DMA_FULL_TRANSFER, HAL_MAX_DELAY);\r\n}\r\n<\/pre>\nThe function above enables the DMA controller #2 (according to the STM32F410RB documentation, DMA#1 cannot be used for memory-to-memory transfers), and performs a single memory-to-memory transfer operation between s_Buffer1<\/strong> and s_Buffer2<\/strong>.<\/li>\n
- Run the new program and step over the function calls in main()<\/strong> to obtain the updated timings:
![\"\"](\"https:\/\/visualgdb.com\/w\/wp-content\/uploads\/2019\/06\/10-dma2.png\")
<\/a>Using DMA instead actually required more time than calling memcpy()<\/strong>, due to the initial setup (20 uS extra), however the CPU spent most of that time looping inside\u00a0HAL_DMA_PollForTransfer()<\/strong> waiting for the DMA transfer to finish.<\/li>\n- As the DMA transfers do not actually involve the CPU, we can easily change the program to compute the Fibonacci numbers in parallel with the DMA transfer:\n
status = HAL_DMA_Start(&s_DMAHandle, (uint32_t)s_Buffer1, (uint32_t)s_Buffer2, sizeof(s_Buffer1) \/ 4);\r\n if (status != HAL_OK)\r\n asm(\"bkpt 255\");\r\n\r\n CalculateFibonacci();\r\n\r\n HAL_DMA_PollForTransfer(&s_DMAHandle, HAL_DMA_FULL_TRANSFER, HAL_MAX_DELAY);<\/pre>\n
<\/li>\n
- Run the modified version of the program and observe the new timings:
![\"\"](\"https:\/\/visualgdb.com\/w\/wp-content\/uploads\/2019\/06\/11-parallel.png\")
<\/a><\/li>\n- Now the DMA operation ran in parallel with the CalculateFibonacci() function, reducing the overall program time by 21%:
![\"\"](\"https:\/\/visualgdb.com\/w\/wp-content\/uploads\/2019\/06\/timing2.png\")
<\/a><\/li>\n- The DMA can be especially useful to optimize data transfers between the memory and various on-chip peripherals. E.g. we can modify the example above to output the contents of s_Buffer1<\/strong> via the UART interface. Before we can do that, add the following function to your program to initialize the on-board UART peripheral:\n
#include <stm32f4xx_hal_uart.h>\r\nstatic UART_HandleTypeDef s_UARTHandle;\r\n\r\nstatic void SetupUART()\r\n{\r\n __USART2_CLK_ENABLE();\r\n s_UARTHandle.Instance = USART2;\r\n\r\n s_UARTHandle.Init.BaudRate = 115200;\r\n s_UARTHandle.Init.WordLength = UART_WORDLENGTH_8B;\r\n s_UARTHandle.Init.StopBits = UART_STOPBITS_1;\r\n s_UARTHandle.Init.Parity = UART_PARITY_NONE;\r\n s_UARTHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE;\r\n s_UARTHandle.Init.Mode = UART_MODE_TX_RX;\r\n s_UARTHandle.Init.OverSampling = UART_OVERSAMPLING_16;\r\n\r\n if (HAL_UART_Init(&s_UARTHandle) != HAL_OK)\r\n asm(\"bkpt 255\");\r\n\r\n GPIO_InitTypeDef GPIO_InitStruct;\r\n __GPIOA_CLK_ENABLE();\r\n\r\n GPIO_InitStruct.Pin = GPIO_PIN_2;\r\n GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;\r\n GPIO_InitStruct.Pull = GPIO_PULLUP;\r\n GPIO_InitStruct.Speed = GPIO_SPEED_FAST;\r\n GPIO_InitStruct.Alternate = GPIO_AF7_USART2;\r\n\r\n HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);\r\n\r\n GPIO_InitStruct.Pin = GPIO_PIN_3;\r\n GPIO_InitStruct.Alternate = GPIO_AF7_USART2;\r\n\r\n HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);\r\n}<\/pre>\nThen call it from main() and try outputting a test string by calling HAL_UART_Transmit():<\/p>\n
SetupUART();\r\n uint8_t test[] = \"test\\n\";\r\n HAL_UART_Transmit(&s_UARTHandle, test, 4, HAL_MAX_DELAY);<\/pre>\n
Note that if you are using a different board than Nucleo-STM32F410RB, you may need to use a different UART (the one that is actually connected to the on-board ST-Link’s COM port) and different GPIO pins. You can find out the UART\/GPIO configuration for your board by cloning one of the ST’s UART examples via the VisualGDB Embedded Project Wizard.<\/li>\n
- Verify that the “test” output is printed to the COM port:
![\"\"](\"https:\/\/visualgdb.com\/w\/wp-content\/uploads\/2019\/06\/12-com.png\")
<\/a><\/li>\n- If you step into the HAL_UART_Transmit()<\/strong> function, you will see that the data is sent to the UART peripheral by writing it byte-by-byte into the UART2->DR<\/strong> register:
![\"\"](\"https:\/\/visualgdb.com\/w\/wp-content\/uploads\/2019\/06\/13-stepin.png\")
<\/a><\/li>\n- The DMA could do exactly that – copy a given buffer to the UART1->DR register byte-by-byte, although there would be several important differences compared to the memory-to-memory operation:\n
- \n
- We cannot use any arbitrary DMA controller. Instead, we need to pick the controller, stream and channel that are connected to the UART2 TX function. This will ensure that the DMA controller will not start transferring another byte until the UART controller is ready to accept it (i.e. has finished physically transmitting the previous one).<\/li>\n
- The DMA mode will need to be changed from DMA_MEMORY_TO_MEMORY<\/strong> to DMA_MEMORY_TO_PERIPH<\/strong>.<\/li>\n
- Unlike the memory-to-memory transfer, where we need to move the write pointer after each transferred word (to avoid overwriting the previous one), the memory-to-UART transfers should always end up at the same address (address of UART1->DR<\/strong>). This is achieved by changing DMA_PINC_ENABLE <\/strong>to DMA_PINC_DISABLE<\/strong>.<\/li>\n
- Because the UART transfers one byte at a time, both peripheral and memory data alignment need to be set at BYTE<\/strong> instead of WORD<\/strong>.<\/li>\n<\/ol>\n
You can find out the DMA stream and channel connected to the UART peripheral in the DMAx request mapping<\/strong> section of your STM32 device’s reference manual (not datasheet):
![\"\"](\"https:\/\/visualgdb.com\/w\/wp-content\/uploads\/2019\/06\/port.png\")
<\/a><\/p>\nThe updated CopyMemoryWithDMA()<\/strong> function outputing the buffer contents to UART will look as follows:<\/p>\n
void __attribute__((noinline)) CopyMemoryWithDMAAndCalclateFibonacci()\r\n{\r\n s_DMAHandle.Instance = DMA1_Stream6;\r\n s_DMAHandle.Init.Channel = DMA_CHANNEL_4;\r\n\r\n s_DMAHandle.Init.Direction = DMA_MEMORY_TO_PERIPH;\r\n s_DMAHandle.Init.PeriphInc = DMA_PINC_DISABLE;\r\n s_DMAHandle.Init.MemInc = DMA_MINC_ENABLE;\r\n s_DMAHandle.Init.Mode = DMA_NORMAL;\r\n s_DMAHandle.Init.Priority = DMA_PRIORITY_VERY_HIGH;\r\n\r\n s_DMAHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;\r\n s_DMAHandle.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;\r\n\r\n s_DMAHandle.Init.FIFOMode = DMA_FIFOMODE_ENABLE;\r\n s_DMAHandle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL;\r\n\r\n __DMA1_CLK_ENABLE();\r\n\r\n HAL_StatusTypeDef status = HAL_DMA_Init(&s_DMAHandle);\r\n if (status != HAL_OK)\r\n asm(\"bkpt 255\");\r\n\r\n status = HAL_DMA_Start(&s_DMAHandle, (uint32_t)s_Buffer1, (uint32_t)&USART2->DR, sizeof(s_Buffer1));\r\n if (status != HAL_OK)\r\n asm(\"bkpt 255\");\r\n\r\n SET_BIT(USART2->CR3, USART_CR3_DMAT);\r\n HAL_DMA_PollForTransfer(&s_DMAHandle, HAL_DMA_FULL_TRANSFER, HAL_MAX_DELAY);\r\n}\r\n<\/pre>\n<\/li>\n- Run the new code and verify that the data transferred to the COM port matches the contents of s_Buffer1<\/strong>:
![\"\"](\"https:\/\/visualgdb.com\/w\/wp-content\/uploads\/2019\/06\/14-bufs.png\")
<\/a><\/li>\n- We can also replace the call to HAL_DMA_Start()<\/strong> that manually specifies the address of USART2->DR<\/strong> and the manual update of the USART2->CR3<\/strong> register with a higher-level call to HAL_UART_Transmit_DMA()<\/strong> that will do the necessary setup automatically:\n
__HAL_LINKDMA(&s_UARTHandle, hdmatx, s_DMAHandle);\r\n status = HAL_UART_Transmit_DMA(&s_UARTHandle, (uint8_t *)s_Buffer1, sizeof(s_Buffer1));<\/pre>\n<\/li>\n
- Finally, we will show how to use the DMA in a scenario that is often impossible with CPU-driven data transfers – generating (or capturing) uninterrupted streams of data. We will update our example to continuously output the stream of Fibonacci numbers to UART without making any breaks by handling the DMA half-transfer interrupts. The DMA controller will be used to repeatedly transfer the same buffer to the UART peripheral over and over, while the CPU will be computing the next batch of values and placing them into the part of the buffer that has already been transferred:
![\"\"](\"https:\/\/visualgdb.com\/w\/wp-content\/uploads\/2019\/06\/timing-1.png\")
<\/a><\/li>\n- To do this, change the DMA mode assigned to s_DMAHandle.Init.Mode from DMA_NORMAL<\/strong> to DMA_CIRCULAR<\/strong>, enable the interrupt for the DMA channel you are using (in this example, by calling HAL_NVIC_EnableIRQ(DMA1_Stream6_IRQn)<\/strong>) and add the following handlers to your main source file:\n
extern \"C\" {\r\n void DMA1_Stream6_IRQHandler()\r\n {\r\n HAL_DMA_IRQHandler(&s_DMAHandle);\r\n }\r\n\r\n void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)\r\n {\r\n asm(\"nop\");\r\n }\r\n\r\n void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart)\r\n {\r\n asm(\"nop\");\r\n }\r\n}<\/pre>\n<\/li>\n- Set a breakpoint in HAL_UART_TxHalfCpltCallback()<\/strong>, let it trigger and check the call stack:
![\"\"](\"https:\/\/visualgdb.com\/w\/wp-content\/uploads\/2019\/06\/15-bkpt.png\")
<\/a>As the call stack shows, the DMA controller has raised an IRQ that invoked the DMA1_Stream6_IRQHandler()<\/strong> we created. In turn, our IRQ handler invoked the standard HAL_DMA_IRQHandler()<\/strong> function that sorted it out as a “Half of DMA buffer transferred” event, invoking the corresponding handler in the UART driver that finally called our HAL_UART_TxHalfCpltCallback() <\/strong>function.<\/li>\n- We can now modify the HAL_UART_TxHalfCpltCallback()<\/strong> and HAL_UART_TxCpltCallback()<\/strong> to fill the second and first half of s_Buffer1<\/strong> respectively with the next batch of Fibonacci numbers. First of all, add an UpdateFibonacci() function shown below:\n
void __attribute__((noinline)) UpdateFibonacci(int *pBuf, size_t count)\r\n{\r\n static int s_Num1 = 0, s_Num2 = 1;\r\n \r\n int tmp1 = s_Num1, tmp2 = s_Num2;\r\n\r\n for (int i = 0; i < (count - 1); i+= 2)\r\n {\r\n pBuf[i] = tmp1;\r\n pBuf[i + 1] = tmp2;\r\n\r\n tmp1 += tmp2;\r\n tmp2 += tmp1;\r\n }\r\n\r\n s_Num1 = tmp1;\r\n s_Num2 = tmp2;\r\n}<\/pre>\nThen, update the UART callbacks as follows:<\/p>\n
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)\r\n {\r\n UpdateFibonacci(s_Buffer1, sizeof(s_Buffer1) \/ sizeof(s_Buffer1[0]) \/ 2);\r\n }\r\n\r\n void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart)\r\n {\r\n const int ElementCount = sizeof(s_Buffer1) \/ sizeof(s_Buffer1[0]);\r\n UpdateFibonacci(s_Buffer1 + ElementCount \/ 2, ElementCount \/ 2);\r\n }<\/pre>\n<\/li>\n- Now you can run the final version of the project and observe an continuous stream of numbers being sent to the COM port:
![\"\"](\"https:\/\/visualgdb.com\/w\/wp-content\/uploads\/2019\/06\/16-nonstop.png\")
<\/a><\/li>\n<\/ol>\n","protected":false},"excerpt":{"rendered":"This tutorial shows how to use the DMA controller on the STM32 devices, letting it perform background memory operations without<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[16],"tags":[180,61],"_links":{"self":[{"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/posts\/4799"}],"collection":[{"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/comments?post=4799"}],"version-history":[{"count":4,"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/posts\/4799\/revisions"}],"predecessor-version":[{"id":6004,"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/posts\/4799\/revisions\/6004"}],"wp:attachment":[{"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/media?parent=4799"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/categories?post=4799"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/tags?post=4799"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
- Unlike the memory-to-memory transfer, where we need to move the write pointer after each transferred word (to avoid overwriting the previous one), the memory-to-UART transfers should always end up at the same address (address of UART1->DR<\/strong>). This is achieved by changing DMA_PINC_ENABLE <\/strong>to DMA_PINC_DISABLE<\/strong>.<\/li>\n