RISC-V技术william hill官网
直播中

voidpbq

8年用户 131经验值
擅长:嵌入式技术,处理器/DSP
私信 关注
[经验]

【芯昇科技RISC-V生态开发板试用体验】3. uart读写

# 1 前言

本章介绍下如何使用uart的rx和tx功能，其中tx利用dma更为方便。

# 2 基础

参考文章：[STM32单片机串口空闲中断+DMA接收不定长数据](https://blog.csdn.net/qq_20222919/article/details/109091456)

uart一次只能收发一字节数据，所以发送相对简单点，直接用函数USART_SendData()，发送多个数据。
但是rx接收时需要等uart状态rx结束，读取到USART_FLAG_RXDNE状态可以收数据。
不过使用dma更为方便，使用usart目录下的DMA_polling示例。

简单介绍下dma：在内存中开辟一段数组空间，uart收到数据后将存入dma中，指针向后移动，直到填满后产生dma中断。
dma中断中可以配置清空等操作。

# 3 引脚介绍

整理了一下开发板的uart端口。
其中usart有三个，分别为usart1-3，uart有四个，分别为uart4-7。
usart相对uart多了时钟信号，用于同步。

其中uart4一般作为和电脑的串口通信，用于打印信息。printf函数显示log就通过uart4传输出来。

yjt.jpg

# 4 硬件

usart3和uart5-7，分别为PC10/11，PB13/14，PB0/1，PC4/5。

2.png

uart4根据威廉希尔官方网站 图来看是接到了PA2/3。推测PA2/3和PA13/12有关联，因为PA13/12是microusb数据线。

3.png

4.png

# 5 代码

主要参考两个示例，usart/printf是用于打印log，usart/dma_polling是用于dma接收数据。

printf示例：https://gitee.com/CMIOT-XinSheng ... amples/USART/Printf

示例源码路径：https://gitee.com/CMIOT-XinSheng ... s/USART/DMA_Polling

打印log使用的uart4，用到的io为PD0/1。
uart收发使用的uart5，用到io为PB13/14。


# 5.1 main.h
头文件定义uart引脚和dma信息。


  1. /*******************************************************************************
  2. *
  3. * COPYRIGHT(c) 2020, China Mobile IOT
  4. *
  5. * Redistribution and use in source and binary forms, with or without modification,
  6. * are permitted provided that the following conditions are met:
  7. *        1. Redistributions of source code must retain the above copyright notice,
  8. *           this list of conditions and the following disclaimer.
  9. *        2. Redistributions in binary form must reproduce the above copyright notice,
  10. *           this list of conditions and the following disclaimer in the documentation
  11. *           and/or other materials provided with the distribution.
  12. *        3. Neither the name of China Mobile IOT nor the names of its contributors
  13. *           may be used to endorse or promote products derived from this software
  14. *           without specific prior written permission.
  15. *
  16. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17. * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19. * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  20. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  22. * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  23. * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  24. * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26. *
  27. *******************************************************************************/

  29. /**
  30. * [url=home.php?mod=space&uid=1455510]@file[/url] main.h
  31. * [url=home.php?mod=space&uid=40524]@author[/url] CMIOT Firmware Team
  32. * [url=home.php?mod=space&uid=644434]@version[/url] v1.0.0
  33. *
  34. * [url=home.php?mod=space&uid=855824]@copyright[/url] Copyright (c) 2020, CMIOT. All rights reserved.
  35. */

  37. #ifndef __MAIN_H__
  38. #define __MAIN_H__

  40. #ifdef __cplusplus
  41. extern "C" {
  42. #endif

  44. #include "nuclei_sdk_soc.h"

  46. /* USARTx configuration */
  47. #define _USART4_COM_

  49. #ifdef _USART4_COM_
  50. #define USARTx                  UART4
  51. #define USARTx_GPIO             GPIOD
  52. #define USARTx_CLK              RCC_APB1_PERIPH_UART4
  53. #define USARTx_GPIO_CLK                RCC_APB2_PERIPH_GPIOD
  54. #define USARTx_RxPin            GPIO_PIN_1
  55. #define USARTx_TxPin            GPIO_PIN_0

  57. #define GPIO_APBxClkCmd                RCC_EnableAPB2PeriphClk
  58. #define USART_APBxClkCmd        RCC_EnableAPB1PeriphClk
  59. #endif

  61. #define _USART5_USART6_

  63. #ifdef _USART5_USART6_
  64. #define USARTy                      UART5
  65. #define USARTy_GPIO                 GPIOB
  66. #define USARTy_CLK                  RCC_APB1_PERIPH_UART5
  67. #define USARTy_GPIO_CLK             RCC_APB2_PERIPH_GPIOB
  68. #define USARTy_TxPin                GPIO_PIN_13
  69. #define USARTy_RxPin                GPIO_PIN_14
  70. #define USARTy_APBxClkCmd           RCC_EnableAPB1PeriphClk
  71. #define USARTy_DMAx                 DMA1
  72. #define USARTy_DMAx_CLK             RCC_AHB_PERIPH_DMA1
  73. #define USARTy_DR_Base              (UART5_BASE + 0x04)
  74. #define USARTy_Tx_DMA_Channel       DMA1_CH1
  75. #define USARTy_Tx_DMA_FLAG          DMA1_FLAG_TC1
  76. #define USARTy_Rx_DMA_Channel       DMA1_CH8
  77. #define USARTy_Rx_DMA_FLAG          DMA1_FLAG_TC8
  78. #define USARTy_Tx_DMA_IRQn          DMA1_Channel1_IRQn
  79. #define USARTy_Tx_DMA_IRQHandler    DMA1_Channel1_IRQHandler
  80. #define USARTy_Tx_DMA_INT           DMA1_INT_TXC1

  82. #define USARTz                      UART6
  83. #define USARTz_GPIO                 GPIOB
  84. #define USARTz_CLK                  RCC_APB2_PERIPH_UART6
  85. #define USARTz_GPIO_CLK             RCC_APB2_PERIPH_GPIOB
  86. #define USARTz_TxPin                GPIO_PIN_0
  87. #define USARTz_RxPin                GPIO_PIN_1
  88. #define USARTz_APBxClkCmd           RCC_EnableAPB2PeriphClk
  89. #define USARTz_DMAx                 DMA2
  90. #define USARTz_DMAx_CLK             RCC_AHB_PERIPH_DMA2
  91. #define USARTz_DR_Base              (UART6_BASE + 0x04)
  92. #define USARTz_Tx_DMA_Channel       DMA2_CH2
  93. #define USARTz_Tx_DMA_FLAG          DMA2_FLAG_TC2
  94. #define USARTz_Rx_DMA_Channel       DMA2_CH1
  95. #define USARTz_Rx_DMA_FLAG          DMA2_FLAG_TC1
  96. #define USARTz_Rx_DMA_IRQn          DMA2_Channel1_IRQn
  97. #define USARTz_Rx_DMA_IRQHandler    DMA2_Channel1_IRQHandler
  98. #define USARTz_Rx_DMA_INT           DMA2_INT_TXC1
  99. #define USARTz_IRQn                       UART6_IRQn
  100. #endif

  102. #ifdef __cplusplus
  103. }
  104. #endif

  106. #endif /* __MAIN_H__ */


# 5.2 main.c

实现uart测试功能。

测试1：dma的tx传输
测试2：uart传输字符串
测试3：dma的rx接收


  1. /*******************************************************************************
  2. *
  3. * COPYRIGHT(c) 2020, China Mobile IOT
  4. *
  5. * Redistribution and use in source and binary forms, with or without modification,
  6. * are permitted provided that the following conditions are met:
  7. *    1. Redistributions of source code must retain the above copyright notice,
  8. *       this list of conditions and the following disclaimer.
  9. *    2. Redistributions in binary form must reproduce the above copyright notice,
  10. *       this list of conditions and the following disclaimer in the documentation
  11. *       and/or other materials provided with the distribution.
  12. *    3. Neither the name of China Mobile IOT nor the names of its contributors
  13. *       may be used to endorse or promote products derived from this software
  14. *       without specific prior written permission.
  15. *
  16. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17. * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19. * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  20. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  22. * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  23. * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  24. * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26. *
  27. *******************************************************************************/

  29. /**
  30. * @file main.c
  31. * @author CMIOT Firmware Team
  32. * @version v1.0.0
  33. *
  34. * @copyright Copyright (c) 2020, CMIOT. All rights reserved.
  35. */

  37. #include
  38. #include "main.h"

  40. /** @addtogroup CM32M4xxR_StdPeriph_Examples
  41. * @{
  42. */

  44. /** @addtogroup USART_DMA_Polling
  45. * @{
  46. */

  48. typedef enum
  49. {
  50.     FAILED = 0,
  51.     PASSED = !FAILED
  52. } TestStatus;

  54. #define TxBufferSize1 (countof(TxBuffer1) - 1)
  55. #define TxBufferSize2 (countof(TxBuffer2) - 1)

  57. #define countof(a) (sizeof(a) / sizeof(*(a)))

  59. USART_InitType USART_InitStructure;
  60. uint8_t TxBuffer1[] = "USART DMA Polling: USARTy -> USARTz using DMA";
  61. uint8_t TxBuffer2[] = "USART DMA Polling: USARTz -> USARTy using DMA";
  62. uint8_t RxBuffer1[TxBufferSize2];
  63. uint8_t RxBuffer2[TxBufferSize1];
  64. volatile TestStatus TransferStatus1 = FAILED;
  65. volatile TestStatus TransferStatus2 = FAILED;

  67. void RCC_Configuration(void);
  68. void GPIO_Configuration(void);
  69. void DMA_Configuration(void);

  71. // youkai add
  72. void func_init_uart4();
  73. void print_dma();

  75. bool status_wait_uart = false;
  76. #define UART_STATUS_RX true
  77. #define UART_STATUS_TX false

  79. void print_uart_wait();
  80. void print_uart_wait_end();

  82. void reset_dma_rx();
  83. void reset_dma_tx();
  84. void myUart_rx(uint8_t uart_id,bool rx_tx);
  85. void myUart_tx(uint8_t uart_id,uint8_t * data,uint8_t len_send);
  86. void myUart_senddata(uint8_t uart_id, uint8_t * data,uint8_t len_send);

  88. void myDMA_tx(uint8_t uart_id);

  90. void delay(vu32 nCount);

  92. /**
  93. * [url=home.php?mod=space&uid=2666770]@Brief[/url]  Main program
  94. */
  95. int main(void)
  96. {
  97.     func_init_uart4();

  99.     printf("start initrn");

  101.     printf("-------test1: dma tx---------rn");

  103.     /* System Clocks Configuration */
  104.     RCC_Configuration();

  106.     /* Configure the GPIO ports */
  107.     GPIO_Configuration();

  109.     /* Configure the DMA */
  110.     DMA_Configuration();

  112.     /* USARTy and USARTz configuration ------------------------------------------------------*/
  113.     USART_InitStructure.BaudRate            = 115200;
  114.     USART_InitStructure.WordLength          = USART_WL_8B;
  115.     USART_InitStructure.StopBits            = USART_STPB_1;
  116.     USART_InitStructure.Parity              = USART_PE_NO;
  117.     USART_InitStructure.HardwareFlowControl = USART_HFCTRL_NONE;
  118.     USART_InitStructure.Mode                = USART_MODE_RX | USART_MODE_TX;

  120.     /* Configure USARTy and USARTz */
  121.     USART_Init(USARTy, &USART_InitStructure);
  122.     USART_Init(USARTz, &USART_InitStructure);

  124. //    strcpy(TxBuffer1,"hihihihihihihihihihihihihihihihihihihihihihih");
  125. //    printf("TxBuffer1 = [%s]rn",(char*)TxBuffer1);

  127.     /* Enable USARTy DMA Rx and TX request */
  128.     USART_EnableDMA(USARTy, USART_DMAREQ_RX | USART_DMAREQ_TX, ENABLE);

  130.     /* Enable USARTz DMA Rx and TX request */
  131.     USART_EnableDMA(USARTz, USART_DMAREQ_RX | USART_DMAREQ_TX, ENABLE);

  133.     /* Enable USARTy TX DMA1 Channel */
  134.    DMA_EnableChannel(USARTy_Tx_DMA_Channel, ENABLE);

  136.     /* Enable USARTy RX DMA1 Channel */
  137.     DMA_EnableChannel(USARTy_Rx_DMA_Channel, ENABLE);

  139.     /* Enable USARTz TX DMA1 Channel */
  140.     DMA_EnableChannel(USARTz_Tx_DMA_Channel, ENABLE);

  142.     /* Enable USARTz RX DMA1 Channel */
  143.     DMA_EnableChannel(USARTz_Rx_DMA_Channel, ENABLE);

  145.     /* Enable the USARTy and USARTz */
  146.     USART_Enable(USARTy, ENABLE);
  147.     USART_Enable(USARTz, ENABLE);

  149.     // wait until dma send data ok.
  150.     while(DMA_GetFlagStatus(DMA1_FLAG_TC1,USARTy_DMAx)==RESET)
  151.     {
  152.     }

  154.     printf("rn-------test2: uart tx---------rn");
  155.     delay(1000);

  157.     printf("dma tx over.rn");

  159. //    USART_SendData(USARTy,'n');
  160. //    delay();
  161.     char temp_rx[]="hihihi";
  162.     myUart_tx(5,temp_rx,4);
  163. //    reset_dma_rx();

  165.     printf("rn-------test3: uart rx---------rn");
  166.     int count = 0;
  167.     while (1)
  168.     {
  169.         printf("count = %drn",count++);

  171.         myUart_rx(5,UART_STATUS_RX);

  173.     }
  174. }

  176. /**
  177. * @brief  Configures the different system clocks.
  178. */
  179. void RCC_Configuration(void)
  180. {
  181.     /* DMA clock enable */
  182.     RCC_EnableAHBPeriphClk(USARTy_DMAx_CLK, ENABLE);
  183.     RCC_EnableAHBPeriphClk(USARTz_DMAx_CLK, ENABLE);

  185.     /* Enable GPIO clock */
  186.     RCC_EnableAPB2PeriphClk(USARTy_GPIO_CLK | USARTz_GPIO_CLK | RCC_APB2_PERIPH_AFIO, ENABLE);

  188.     /* Enable USARTy and USARTz Clock */
  189.     USARTy_APBxClkCmd(USARTy_CLK, ENABLE);
  190.     USARTz_APBxClkCmd(USARTz_CLK, ENABLE);
  191. }

  193. /**
  194. * @brief  Configures the different GPIO ports.
  195. */
  196. void GPIO_Configuration(void)
  197. {
  198.     GPIO_InitType GPIO_InitStructure;
  199.     GPIO_ConfigPinRemap(GPIO_RMP_USART1,ENABLE);

  201.     /* Configure USARTy Rx as input floating */
  202.     GPIO_InitStructure.Pin       = USARTy_RxPin;
  203.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  204.     GPIO_Init(USARTy_GPIO, &GPIO_InitStructure);

  206.     /* Configure USARTz Rx as input floating */
  207.     GPIO_InitStructure.Pin = USARTz_RxPin;
  208.     GPIO_Init(USARTz_GPIO, &GPIO_InitStructure);

  210.     /* Configure USARTy Tx as alternate function push-pull */
  211.     GPIO_InitStructure.Pin        = USARTy_TxPin;
  212.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  213.     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;
  214.     GPIO_Init(USARTy_GPIO, &GPIO_InitStructure);

  216.     /* Configure USARTz Tx as alternate function push-pull */
  217.     GPIO_InitStructure.Pin = USARTz_TxPin;
  218.     GPIO_Init(USARTz_GPIO, &GPIO_InitStructure);

  220.     GPIO_ConfigPinRemap(GPIO_RMP1_UART5, ENABLE);
  221.     GPIO_ConfigPinRemap(GPIO_RMP3_UART6, ENABLE);
  222. }

  224. /**
  225. * @brief  Configures the DMA.
  226. */
  227. void DMA_Configuration(void)
  228. {
  229.     DMA_InitType DMA_InitStructure;

  231.     /* USARTy TX DMA1 Channel (triggered by USARTy Tx event) Config */
  232.     DMA_DeInit(USARTy_Tx_DMA_Channel);
  233.     DMA_InitStructure.PeriphAddr     = USARTy_DR_Base;
  234.     DMA_InitStructure.MemAddr        = (uint32_t)TxBuffer1;
  235.     DMA_InitStructure.Direction      = DMA_DIR_PERIPH_DST;
  236.     DMA_InitStructure.BufSize        = TxBufferSize1;
  237.     DMA_InitStructure.PeriphInc      = DMA_PERIPH_INC_DISABLE;
  238.     DMA_InitStructure.DMA_MemoryInc  = DMA_MEM_INC_ENABLE;
  239.     DMA_InitStructure.PeriphDataSize = DMA_PERIPH_DATA_SIZE_BYTE;
  240.     DMA_InitStructure.MemDataSize    = DMA_MEMORY_DATA_SIZE_BYTE;
  241.     DMA_InitStructure.CircularMode   = DMA_MODE_NORMAL;
  242.     DMA_InitStructure.Priority       = DMA_PRIORITY_VERY_HIGH;
  243.     DMA_InitStructure.Mem2Mem        = DMA_M2M_DISABLE;
  244.     DMA_Init(USARTy_Tx_DMA_Channel, &DMA_InitStructure);

  246.     /* USARTy RX DMA1 Channel (triggered by USARTy Rx event) Config */
  247.     DMA_DeInit(USARTy_Rx_DMA_Channel);
  248.     DMA_InitStructure.PeriphAddr = USARTy_DR_Base;
  249.     DMA_InitStructure.MemAddr    = (uint32_t)RxBuffer1;
  250.     DMA_InitStructure.Direction  = DMA_DIR_PERIPH_SRC;
  251.     DMA_InitStructure.BufSize    = TxBufferSize2;
  252.     DMA_Init(USARTy_Rx_DMA_Channel, &DMA_InitStructure);

  254.     /* USARTz TX DMA1 Channel (triggered by USARTz Tx event) Config */
  255.     DMA_DeInit(USARTz_Tx_DMA_Channel);
  256.     DMA_InitStructure.PeriphAddr = USARTz_DR_Base;
  257.     DMA_InitStructure.MemAddr    = (uint32_t)TxBuffer2;
  258.     DMA_InitStructure.Direction  = DMA_DIR_PERIPH_DST;
  259.     DMA_InitStructure.BufSize    = TxBufferSize2;
  260.     DMA_Init(USARTz_Tx_DMA_Channel, &DMA_InitStructure);

  262.     /* USARTz RX DMA1 Channel (triggered by USARTz Rx event) Config */
  263.     DMA_DeInit(USARTz_Rx_DMA_Channel);
  264.     DMA_InitStructure.PeriphAddr = USARTz_DR_Base;
  265.     DMA_InitStructure.MemAddr    = (uint32_t)RxBuffer2;
  266.     DMA_InitStructure.Direction  = DMA_DIR_PERIPH_SRC;
  267.     DMA_InitStructure.BufSize    = TxBufferSize1;
  268.     DMA_Init(USARTz_Rx_DMA_Channel, &DMA_InitStructure);
  269. }



  273. void func_init_uart4()
  274. {
  275.     //RCC_Configuration
  276.     /* Enable GPIO clock */
  277.     GPIO_APBxClkCmd(USARTx_GPIO_CLK | RCC_APB2_PERIPH_AFIO, ENABLE);

  279.     /* Enable USARTy and USARTz Clock */
  280.     USART_APBxClkCmd(USARTx_CLK, ENABLE);

  282.     //GPIO_Configuration
  283.     GPIO_InitType GPIO_InitStructure;
  284.     GPIO_ConfigPinRemap(GPIO_RMP_USART1,ENABLE);

  286.     /* Configure USARTx Tx as alternate function push-pull */
  287.     GPIO_InitStructure.Pin        = USARTx_TxPin;
  288.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  289.     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;
  290.     GPIO_Init(USARTx_GPIO, &GPIO_InitStructure);

  292.     /* Configure USARTx Rx as input floating */
  293.     GPIO_InitStructure.Pin       = USARTx_RxPin;
  294.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  295.     GPIO_Init(USARTx_GPIO, &GPIO_InitStructure);

  297.     GPIO_ConfigPinRemap(GPIO_RMP3_UART4, ENABLE);

  299.     //uart
  300.     /* USARTy and USARTz configuration ------------------------------------------------------*/
  301.     USART_InitStructure.BaudRate            = 115200;
  302.     USART_InitStructure.WordLength          = USART_WL_8B;
  303.     USART_InitStructure.StopBits            = USART_STPB_1;
  304.     USART_InitStructure.Parity              = USART_PE_NO;
  305.     USART_InitStructure.HardwareFlowControl = USART_HFCTRL_NONE;
  306.     USART_InitStructure.Mode                = USART_MODE_RX | USART_MODE_TX;

  308.     /* Configure USARTx */
  309.     USART_Init(USARTx, &USART_InitStructure);

  311.     /* Enable the USARTx */
  312.     USART_Enable(USARTx, ENABLE);

  314. }


  317. void print_dma()
  318. {
  319. //    printf("TxBuffer1 = [%s]rn",(char*)TxBuffer1);
  320. //    printf("TxBuffer2 = [%s]rn",(char*)TxBuffer2);
  321.     printf("RxBuffer1 = [%s]rn",(char*)RxBuffer1);
  322. //    printf("RxBuffer2 = [%s]rn",(char*)RxBuffer2);
  323.     printf("rn");
  324. }



  328. void print_uart_wait()
  329. {
  330.     if(status_wait_uart == true)
  331.     {
  332.         status_wait_uart = false;
  333.         printf("uart transfer waiting......rn");
  334.     }
  335. }

  337. void print_uart_wait_end()
  338. {
  339.     status_wait_uart = true;
  340.     printf("end uart wait.rn");
  341. }

  343. void myDMA_tx(uint8_t uart_id)
  344. {

  346.     // choose dma
  347.     DMA_Module* dma =  USARTy_Tx_DMA_Channel;
  348.     uint32_t dma_flag = DMA1_FLAG_TC1;
  349.     switch(uart_id)
  350.     {
  351.     case 5:
  352.             dma =  USARTy_Tx_DMA_Channel;
  353.             dma_flag= DMA1_FLAG_TC1;
  354.             break;
  355.     case 6:
  356.             dma =  USARTz_Tx_DMA_Channel;
  357.             dma_flag = DMA2_FLAG_TC8;
  358.             break;
  359.     default:
  360.             printf("use default uart5rn");
  361.             dma =  USARTy_Tx_DMA_Channel;
  362.             dma_flag = DMA1_FLAG_TC1;
  363.             break;
  364.     }

  366.     printf("sendrn");
  367.     // tx : send uart data to other dev
  368.     while (DMA_GetFlagStatus(dma_flag, dma) == RESET)
  369.     {
  370.         print_uart_wait();
  371.     }
  372.     print_uart_wait_end();



  376. }

  378. void myUart_senddata(uint8_t uart_id,uint8_t* data, uint8_t len_send)
  379. {
  380.     uint8_t * temp_value = data;
  381.     uint8_t temp_len = len_send;

  383.     printf("len_send = %d, strvalue = [%s]rn",temp_len,(char * )data);

  385.     // choose uart
  386.     USART_Module* uart =  USARTy;
  387.     switch(uart_id)
  388.     {
  389.     case 5:
  390.             uart = USARTy;
  391.             break;
  392.     case 6:
  393.             uart = USARTz;
  394.             break;
  395.     default:
  396.             printf("use default uart5rn");
  397.             uart = USARTy;
  398.             break;
  399.     }

  401.     int i=0;
  402.     while(temp_len > i)
  403.     {
  404. //        printf("i = %d, value = %02xrn",i,*temp_value);
  405.         USART_SendData(uart,*temp_value);

  407.         // wait until data has send
  408.         while(USART_GetFlagStatus(uart,USART_FLAG_TXDE)==RESET)
  409.         {

  411.         }

  413.         i++;
  414.         temp_value++;
  415.     }
  416.     return;
  417. }

  419. void myUart_tx(uint8_t uart_id,uint8_t * data,uint8_t len_send)
  420. {
  421.     int len_str = strlen(data);

  423.     bool str_data = len_send>=len_str;

  425.     // if send overside strlen, just send strlen
  426.     int len = str_data? len_str:len_send;
  427.     printf("strlen = %d, send len = %d, send>strlen = %srn",len_str,len_send,
  428.             str_data?"true":"false");

  430.     if(str_data == true)
  431.     {
  432.         printf("send data len overside str_len.rn");
  433.     }
  434.     else
  435.     {
  436.         printf("send data len = %d.rn",len_send);
  437.     }

  439.     myUart_senddata(uart_id,data,len);
  440. }

  442. void myUart_rx(uint8_t uart_id,bool rx_tx)
  443. {
  444.     USART_Module * uart = USARTy;
  445.     DMA_Module * dma = USARTy_Rx_DMA_Channel;

  447.     switch(uart_id)
  448.     {
  449.     case 5:
  450.             uart = USARTy;
  451.             dma = USARTy_Rx_DMA_Channel;
  452.             break;
  453.     case 6:
  454.             uart = USARTz;
  455.             dma = USARTz_Rx_DMA_Channel;
  456.             break;
  457.     default:
  458.             printf("use default uart5rn");
  459.             uart = USARTy;
  460.             break;
  461.     }

  463. //    printf("receivern");
  464.     // rx : get uart data from other dev
  465.     /* Wait until USARTy get idlef */
  466.     while (USART_GetFlagStatus(uart, USART_FLAG_IDLEF) == RESET)
  467.     {
  468.         print_uart_wait();
  469.     }
  470.     print_uart_wait_end();

  472.     printf("uart is idlefrn");

  474.     int dma_last = DMA_GetCurrDataCounter(USARTy_Rx_DMA_Channel);
  475.     printf("dma get count =%d rn",dma_last);

  477.     printf("has recv data len = %drn",TxBufferSize2-dma_last);

  479.     reset_dma_rx();
  480. }

  482. void reset_dma_rx()
  483. {
  484.     print_dma();

  486.     memset(RxBuffer1,0x00,sizeof(RxBuffer1));
  487.     DMA_EnableChannel(USARTy_Rx_DMA_Channel, DISABLE);

  489.     DMA_SetCurrDataCounter(USARTy_Rx_DMA_Channel,TxBufferSize1);

  491.     DMA_EnableChannel(USARTy_Rx_DMA_Channel, ENABLE);

  493.     // clear idlef flag
  494.     USART_ReceiveData(USARTy);
  495. }

  497. void reset_dma_tx()
  498. {
  499.     print_dma();

  501.     memset(TxBuffer1,0x00,sizeof(TxBuffer1));
  502.     DMA_EnableChannel(USARTy_Rx_DMA_Channel, DISABLE);

  504.     DMA_SetCurrDataCounter(USARTy_Rx_DMA_Channel,TxBufferSize1);

  506.     DMA_EnableChannel(USARTy_Rx_DMA_Channel, ENABLE);

  508.     // clear idlef flag
  509.     USART_ReceiveData(USARTy);
  510. }

  512. /**
  513. * @brief  Delay function.
  514. */
  515. void delay(vu32 nCount)
  516. {
  517.     vu32 index = 0;
  518.     for (index = (34000 * nCount); index != 0; index--)
  519.     {
  520.     }
  521. }


# 6 结果


rx_结果.png

可以看到，串口接收工具
1. 收到dma传输的字符串
2. 收到通过uart函数传输的字符串
3. 向uart5发出不定长度的数据，log中显示出来获取的数据及长度。

# 7 使用函数

USART_SendData：uart传输数据tx
USART_GetFlagStatus：获取uart状态，根据传入的uart和flag，返回set表示该flag已经设置，则跳出while循环

DMA_GetCurrDataCounter：获取dma剩余空间长度，用于计算当前收到了多少数据。

DMA_EnableChannel：开关dma的channel，两个dma，每个有8channel。
DMA_SetCurrDataCounter：设置当前dma的指针。
PS：收到过一次后需要开关dma，然后重新设置当前数据数。

此外，由于判断dma收到数据状态，通过判断usart的idle，空闲中断。
当判定到uart收到空闲中断，则表示uart数据传输完成。不过该状态清空需要使用到receive函数。
USART_ReceiveData：uart接收数据rx。

# 8 小结

本章介绍了结合uart及dma实现数据的收发，后续再结合串口屏实现功能。



更多回帖

0 0 0

相关帖子

RISC-V uart 芯昇科技
发帖
电子发烧友APP
|投诉反馈|电子发烧友网
© 2021 bbs.elecfans.com
湘ICP备2023018690号
×
20
完善资料，
赚取积分