21ic电子技术开发论坛 › 单片机与嵌入式系统 › GigaDevice GD32 MCU › GD32F103/303串口+空闲中断连续接收数据
12下一页
返回列表 发新帖我要提问

[研电赛技术支持] GD32F103/303串口+空闲中断连续接收数据

[复制链接]
2128|22
 楼主| t61000 发表于 2022-11-18 15:29 | 显示全部楼层 |阅读模式
gd32F103, gd32f1, 串口
头文件#ifndef _UART_H_
#define _UART_H_

#include "stdint.h"
#include "gd32f30x.h"
#define CACHE_NUM 128



//数据接收处理函数
typedef void (*recv_hanled)(uint8_t *data, uint16_t len);

typedef struct
{

    uint32_t usart_periph;                        //外设名称
    uint32_t dma_periph;                                //dma 外设
    dma_channel_enum dma_channelx;//dma外设通道
    uint8_t dma_nvic_irq;                         //dma中断号
    uint8_t uart_nvic_irq;                        //串口中断号
    uint8_t dma_or_idle;                                //传输完成标记和收到一帧数据标记dm
    uint16_t data_num;                                        //已经接收到的数据量
    uint8_t uart_rx_buffers[CACHE_NUM];//接收数据缓冲区
    recv_hanled hanled_fun;                        //数据接收处理函数
} uart_dam_t;


//初始化串口涉及的时钟和gpio gpio USART/UART
void bsp_uart_gpio_rcu_init(uint32_t usart_periph);

/*基本初始化函数*/
void bsp_uart_usart_base_init(uint32_t usart_periph);

//串口相关自定义结构初始化
uart_dam_t * init_uart_dma_struct(uint32_t usart_periph);

//使能串口中断
void bsp_uart_enable_uart_interrupt(uart_dam_t *puart_dma);

//dma 外设初始化
int bsp_uart_dma_nvic_init(uart_dam_t *puart_dma);

//注册一个处理函数
int bsp_uart_register_handle(uart_dam_t *puart_dma, recv_hanled hanled_fun);

循环调用函数,处理串口信息
void bsp_uart_dma_procees(uint32_t tick);
#endif



回复

收藏1 举报

相关帖子
 楼主| t61000 发表于 2022-11-18 15:32 | 显示全部楼层
源文件
复制
  1. #include "uart.h"
    

  2. #include "stdio.h"
    

  3. #include "gd32f30x.h"
    


  4. 


  5. 


  6. 


  7. 

  8. //每个串口外设一个自定义结构
    


  9. 

  10. uart_dam_t uart0_dma;
    

  11. uart_dam_t uart1_dma;
    

  12. uart_dam_t uart2_dma;
    

  13. uart_dam_t uart3_dma;
    


  14. 

  15. //接收到的数据个数
    

  16. volatile uint16_t uart_rxcount[5];
    

  17. //串口空闲或缓冲器慢标志
    

  18. volatile uint8_t idle_or_full = 0;
    


  19. 

  20. /* 重定向printf函数 */
    

  21. int fputc(int ch, FILE *f)
    

  22. {
    

  23.     int cnt = 1000;
    

  24.     usart_data_transmit(USART0, (uint8_t)ch);
    


  25. 

  26.     while(RESET == usart_flag_get(USART0, USART_FLAG_TBE) && cnt--);
    


  27. 


  28. 

  29.     usart_data_transmit(USART1, (uint8_t)ch);
    

  30.     cnt = 1000;
    


  31. 

  32.     while(RESET == usart_flag_get(USART1, USART_FLAG_TBE) && cnt--);
    


  33. 

  34.     return ch;
    

  35. }
    

  36. //初始化自定义结构体
    

  37. uart_dam_t * init_uart_dma_struct(uint32_t usart_periph)
    

  38. {
    

  39.                 //UART0 DMA0-CH4
    

  40.                 //UART1 DMA0-CH5
    

  41.                 //UART2-DMA0-CH2
    

  42.                 //UART3-DMA1-CH2
    


  43. 


  44. 

  45.     uart_dam_t *puart_dma = NULL;
    


  46. 


  47. 

  48.     if(usart_periph == USART0)
    

  49.     {
    

  50.         puart_dma = &uart0_dma;
    

  51.         puart_dma->dma_periph = DMA0;
    

  52.         puart_dma->dma_channelx = DMA_CH4;
    

  53.         puart_dma->dma_nvic_irq = DMA0_Channel4_IRQn;
    

  54.         puart_dma->uart_nvic_irq = USART0_IRQn;
    

  55.     }
    

  56.     else if(usart_periph == USART1)
    

  57.     {
    

  58.         puart_dma = &uart1_dma;
    

  59.         puart_dma->dma_periph = DMA0;
    

  60.         puart_dma->dma_channelx = DMA_CH5;
    

  61.         puart_dma->dma_nvic_irq = DMA0_Channel5_IRQn;
    

  62.         puart_dma->uart_nvic_irq = USART1_IRQn;
    

  63.     }
    

  64.     else if(usart_periph == USART2)
    

  65.     {
    

  66.         puart_dma = &uart2_dma;
    

  67.         puart_dma->dma_periph = DMA0;
    

  68.         puart_dma->dma_channelx = DMA_CH2;
    

  69.         puart_dma->dma_nvic_irq = DMA0_Channel2_IRQn;
    

  70.         puart_dma->uart_nvic_irq = USART2_IRQn;
    

  71.     }
    

  72.     else if(usart_periph == UART3)
    

  73.     {
    

  74.         puart_dma = &uart3_dma;
    

  75.         puart_dma->dma_periph = DMA1;
    

  76.         puart_dma->dma_channelx = DMA_CH2;
    

  77.         puart_dma->dma_nvic_irq = DMA0_Channel2_IRQn;
    

  78.         puart_dma->uart_nvic_irq = UART3_IRQn;
    

  79.     }
    


  80. 

  81.     puart_dma->usart_periph = usart_periph;
    

  82.     return puart_dma;
    

  83. }
    


  84. 


  85. 

  86. /*!
    

  87.     \brief      初始化串口涉及的时钟和gpio gpio USART/UART
    

  88.     \param[in]  usart_periph: USARTx(x=0,1,2)/UARTx(x=3,4)
    

  89.     \param[out] none
    

  90.     \retval     none
    

  91. */
    


  92. 

  93. void bsp_uart_gpio_rcu_init(uint32_t usart_periph)
    

  94. {
    

  95.     /*********************串口0********************/
    

  96.     if(usart_periph == USART0)
    

  97.     {
    

  98.         /* 使能串口时钟 */
    

  99.         rcu_periph_clock_enable(RCU_USART0);
    

  100.         /* 使能gpio时钟 */
    

  101.         rcu_periph_clock_enable(RCU_GPIOA);
    


  102. 

  103.         /* gpio IO 初始化发送引脚 */
    

  104.         gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_9);
    

  105.         /* 初始化接收引脚 */
    

  106.         gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_10);
    

  107.     }
    

  108.     /*********************串口0********************/
    


  109. 

  110.     /*********************串口1********************/
    

  111.     else if(usart_periph == USART1)
    

  112.     {
    

  113.         /* 使能串口时钟 */
    

  114.         rcu_periph_clock_enable(RCU_USART1);
    


  115. 

  116.         /* 使能gpio时钟 */
    

  117.         rcu_periph_clock_enable(RCU_GPIOA);
    


  118. 

  119.         /* gpio IO 初始化发送引脚 */
    

  120.         gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_2);
    

  121.         /* 初始化接收引脚 */
    

  122.         gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_3);
    

  123.     }
    

  124.     /*********************串口1********************/
    


  125. 

  126.     /*********************串口2********************/
    

  127.     else if(usart_periph == USART2)
    

  128.     {
    

  129.         /* 使能串口时钟 */
    

  130.         rcu_periph_clock_enable(RCU_USART2);
    


  131. 

  132.         /* 使能gpio时钟 */
    

  133.         rcu_periph_clock_enable(RCU_GPIOB);
    


  134. 

  135.         /* gpio IO 初始化发送引脚 */
    

  136.         gpio_init(GPIOB, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_10);
    

  137.         /* 初始化接收引脚 */
    

  138.         gpio_init(GPIOB, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_11);
    


  139. 

  140.     }
    

  141.     /*********************串口2********************/
    


  142. 

  143.     /*********************串口3********************/
    

  144.     else if(usart_periph == UART3)
    

  145.     {
    

  146.         /* 使能串口时钟 */
    

  147.         rcu_periph_clock_enable(RCU_UART3);
    


  148. 

  149.         /* 使能gpio时钟 */
    

  150.         rcu_periph_clock_enable(RCU_GPIOC);
    


  151. 

  152.         /* gpio IO 初始化发送引脚 */
    

  153.         gpio_init(GPIOC, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_10);
    

  154.         /* 初始化接收引脚 */
    

  155.         gpio_init(GPIOC, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_11);
    


  156. 

  157.     }
    

  158.     /*********************串口3********************/
    


  159. 

  160.     /*********************串口4********************/
    

  161.     else if(usart_periph == UART4)
    

  162.     {
    

  163.         /* 使能串口时钟 */
    

  164.         rcu_periph_clock_enable(RCU_UART4);
    

  165.     }
    


  166. 

  167.     /*********************串口4********************/
    


  168. 

  169. }
    


  170. 

  171. /*基本初始化函数*/
    

  172. void bsp_uart_usart_base_init(uint32_t usart_periph)
    

  173. {
    

  174.     //外设的gpio初始化和时钟初始化
    

  175.     bsp_uart_gpio_rcu_init(usart_periph);
    


  176. 

  177.     /* USART configure 串口参数初始化 */
    

  178.     usart_deinit(usart_periph);
    

  179.     //设置波特率
    

  180.     usart_baudrate_set(usart_periph, 115200U);
    

  181.     //设置数据长度
    

  182.     usart_word_length_set(usart_periph, USART_WL_8BIT);
    

  183.     //设置停止位
    

  184.     usart_stop_bit_set(usart_periph, USART_STB_1BIT);
    

  185.     //设置检验位
    

  186.     usart_parity_config(usart_periph, USART_PM_NONE);
    

  187.     //硬件流管理 都关闭
    

  188.     usart_hardware_flow_rts_config(usart_periph, USART_RTS_DISABLE);
    

  189.     usart_hardware_flow_cts_config(usart_periph, USART_CTS_DISABLE);
    

  190.     //串口接收使能
    

  191.     usart_receive_config(usart_periph, USART_RECEIVE_ENABLE);
    

  192.     //串口发送使能
    

  193.     usart_transmit_config(usart_periph, USART_TRANSMIT_ENABLE);
    

  194.     //使能串口
    

  195.     usart_enable(usart_periph);
    

  196. }
    


  197. 


  198. 

  199. /*
    

  200.         使能串口中断
    

  201. */
    

  202. void bsp_uart_enable_uart_interrupt(uart_dam_t *puart_dma)
    

  203. {
    

  204.     /*中断管理器使能，并分配优先级*/
    


  205. 

  206.     nvic_irq_enable(puart_dma->uart_nvic_irq, 1, 1);
    


  207. 

  208.     /*清除中断标志*/
    

  209.     usart_interrupt_flag_clear(puart_dma->usart_periph, USART_INT_FLAG_IDLE);
    

  210.     /* 使能串口中断 */
    

  211.     usart_interrupt_enable(puart_dma->usart_periph, USART_INT_IDLE);//空闲中断
    

  212. }
    


  213. 


  214. 


  215. 

  216. /*
    

  217.         功能：DMA 中断接收数据,uart5 不可以使用dma传输数据
    

  218.         hope_len：希望接收的数据个数
    

  219.         circulation：是否使用连续模式
    

  220. */
    

  221. int  bsp_uart_dma_nvic_init(uart_dam_t *puart_dma)
    

  222. {
    

  223.     dma_parameter_struct dma_init_struct;
    


  224. 

  225.     if(puart_dma == NULL)
    

  226.     {
    

  227.         return 0;
    

  228.     }
    


  229. 

  230.     /* enable DMA0 clock 使能DMA0 的时钟*/
    

  231.     if(puart_dma->usart_periph == USART0 ||
    

  232.             puart_dma->usart_periph == USART1 ||
    

  233.             puart_dma->usart_periph == USART2)
    

  234.     {
    

  235.         rcu_periph_clock_enable(RCU_DMA0);
    

  236.     }
    

  237.     else if(puart_dma->usart_periph == UART3)
    

  238.     {
    

  239.         rcu_periph_clock_enable(RCU_DMA1);
    

  240.     }
    


  241. 

  242.     //中断管理器开启通道中断
    

  243.     nvic_irq_enable(puart_dma->dma_nvic_irq, 0, 1);
    

  244.     // 复位代码指定通道
    

  245.     dma_deinit(puart_dma->dma_periph, puart_dma->dma_channelx);
    

  246.     dma_struct_para_init(&dma_init_struct);
    

  247.     dma_init_struct.direction = DMA_PERIPHERAL_TO_MEMORY; //外设到内存
    

  248.     dma_init_struct.memory_addr = (uint32_t)puart_dma->uart_rx_buffers;        //接收缓冲区开始地址
    

  249.     dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;//内存地址自动增长
    

  250.     dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;//数据长度8bit
    

  251.     dma_init_struct.number = CACHE_NUM;//缓冲区大小
    

  252. #define USART0_DATA_ADDRESS      ((uint32_t)&USART_DATA(USART0))
    

  253.     dma_init_struct.periph_addr = USART0_DATA_ADDRESS;//外设寄存器地址
    

  254.     dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;//外设寄存器地址不自动增加
    

  255.     dma_init_struct.memory_width = DMA_PERIPHERAL_WIDTH_8BIT;//外输数据宽度
    

  256.     dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;//DMA优先级
    

  257.     dma_init(puart_dma->dma_periph, puart_dma->dma_channelx, &dma_init_struct);
    

  258.     dma_circulation_enable(puart_dma->dma_periph, puart_dma->dma_channelx);//连续传输
    


  259. 

  260.     //数据传输方式不是内存到内存
    

  261.     dma_memory_to_memory_disable(puart_dma->dma_periph, puart_dma->dma_channelx);
    


  262. 

  263.     /* USART DMA0 串口0DMA 数据接收使能 */
    

  264.     usart_dma_receive_config(puart_dma->usart_periph, USART_DENR_ENABLE);
    

  265.     /* enable DMA0 串口0 DMA 接收完成中断使能 */
    

  266.     dma_interrupt_enable(puart_dma->dma_periph, puart_dma->dma_channelx, DMA_INT_FTF);
    

  267.     /* enable DMA0 启用指定的DMA通道*/
    

  268.     dma_channel_enable(puart_dma->dma_periph, puart_dma->dma_channelx);
    

  269.     return 1;
    

  270. }
    


  271. 

  272. /*
    

  273.         禁止中断和DMA
    

  274. */
    

  275. void  bsp_uart0_init_idle_it_disable()
    

  276. {
    

  277.     //禁止中断
    

  278.     nvic_irq_disable(USART0_IRQn);
    

  279.     usart_interrupt_disable(USART0, USART_INT_IDLE);//空闲中断
    

  280.     //禁止DMA
    

  281.     dma_channel_disable(DMA0, DMA_CH4);
    


  282. 

  283. }
    


  284. 

  285. /*
    

  286.         串口0中断处理函数
    

  287. */
    

  288. void USART0_IRQHandler(void)
    

  289. {
    

  290.     uart_dam_t *p_uart_dma = &uart0_dma;
    


  291. 

  292.     if(RESET != usart_interrupt_flag_get(p_uart_dma->usart_periph, USART_INT_FLAG_IDLE))
    

  293.     {
    

  294.         usart_data_receive(p_uart_dma->usart_periph);
    


  295. 


  296. 

  297.         p_uart_dma->data_num = CACHE_NUM - dma_transfer_number_get(p_uart_dma->dma_periph, p_uart_dma->dma_channelx);
    


  298. 

  299.         p_uart_dma->dma_or_idle = 1;
    

  300.         //重新使能dma，重新计算剩余未传输数量
    

  301.         dma_channel_disable(p_uart_dma->dma_periph, p_uart_dma->dma_channelx);
    

  302.         DMA_CHCNT(p_uart_dma->dma_periph, p_uart_dma->dma_channelx) = CACHE_NUM;
    

  303.         dma_channel_enable(p_uart_dma->dma_periph, p_uart_dma->dma_channelx);
    


  304. 

  305.     }
    

  306. }
    

  307. /*
    

  308.         串口3中断处理函数
    

  309. */
    

  310. void USART1_IRQHandler(void)
    

  311. {
    

  312.     uart_dam_t *p_uart_dma = &uart1_dma;
    


  313. 

  314.     if(RESET != usart_interrupt_flag_get(p_uart_dma->usart_periph, USART_INT_FLAG_IDLE))
    

  315.     {
    

  316.         usart_data_receive(p_uart_dma->usart_periph);
    


  317. 


  318. 

  319.         p_uart_dma->data_num = CACHE_NUM - dma_transfer_number_get(p_uart_dma->dma_periph, p_uart_dma->dma_channelx);
    


  320. 

  321.         p_uart_dma->dma_or_idle = 1;
    

  322.         //重新使能dma，重新计算剩余未传输数量
    

  323.         dma_channel_disable(p_uart_dma->dma_periph, p_uart_dma->dma_channelx);
    

  324.         DMA_CHCNT(p_uart_dma->dma_periph, p_uart_dma->dma_channelx) = CACHE_NUM;
    

  325.         dma_channel_enable(p_uart_dma->dma_periph, p_uart_dma->dma_channelx);
    


  326. 

  327.     }
    

  328. }
    

  329. /*
    

  330.         串口2中断处理函数
    

  331. */
    

  332. void USART2_IRQHandler(void)
    

  333. {
    

  334.     uart_dam_t *p_uart_dma = &uart2_dma;
    


  335. 

  336.     if(RESET != usart_interrupt_flag_get(p_uart_dma->usart_periph, USART_INT_FLAG_IDLE))
    

  337.     {
    

  338.         usart_data_receive(p_uart_dma->usart_periph);
    


  339. 


  340. 

  341.         p_uart_dma->data_num = CACHE_NUM - dma_transfer_number_get(p_uart_dma->dma_periph, p_uart_dma->dma_channelx);
    


  342. 

  343.         p_uart_dma->dma_or_idle = 1;
    

  344.         //重新使能dma，重新计算剩余未传输数量
    

  345.         dma_channel_disable(p_uart_dma->dma_periph, p_uart_dma->dma_channelx);
    

  346.         DMA_CHCNT(p_uart_dma->dma_periph, p_uart_dma->dma_channelx) = CACHE_NUM;
    

  347.         dma_channel_enable(p_uart_dma->dma_periph, p_uart_dma->dma_channelx);
    


  348. 

  349.     }
    

  350. }
    

  351. /*
    

  352.         串口3中断处理函数
    

  353. */
    

  354. void UART3_IRQHandler(void)
    

  355. {
    

  356.     uart_dam_t *p_uart_dma = &uart3_dma;
    


  357. 

  358.     if(RESET != usart_interrupt_flag_get(p_uart_dma->usart_periph, USART_INT_FLAG_IDLE))
    

  359.     {
    

  360.         usart_data_receive(p_uart_dma->usart_periph);
    


  361. 


  362. 

  363.         p_uart_dma->data_num = CACHE_NUM - dma_transfer_number_get(p_uart_dma->dma_periph, p_uart_dma->dma_channelx);
    


  364. 

  365.         p_uart_dma->dma_or_idle = 1;
    

  366.         //重新使能dma，重新计算剩余未传输数量
    

  367.         dma_channel_disable(p_uart_dma->dma_periph, p_uart_dma->dma_channelx);
    

  368.         DMA_CHCNT(p_uart_dma->dma_periph, p_uart_dma->dma_channelx) = CACHE_NUM;
    

  369.         dma_channel_enable(p_uart_dma->dma_periph, p_uart_dma->dma_channelx);
    


  370. 

  371.     }
    

  372. }
    

  373. /*串口0dma*/
    

  374. void DMA0_Channel4_IRQHandler(void)
    

  375. {
    

  376.     uart_dam_t *p_uart_dma = &uart0_dma;
    


  377. 

  378.     //获取中断标记并判断否是置位
    

  379.     if(dma_interrupt_flag_get(p_uart_dma->dma_periph, p_uart_dma->dma_channelx, DMA_INT_FLAG_FTF))
    

  380.     {
    

  381.         //清除dma中断标记
    

  382.         dma_interrupt_flag_clear(p_uart_dma->dma_periph, p_uart_dma->dma_channelx, DMA_INT_FLAG_G);
    

  383.         p_uart_dma->dma_or_idle = SET;
    

  384.     }
    


  385. 

  386. }
    

  387. /*串口1 dma*/
    

  388. void DMA0_Channel5_IRQHandler(void)
    

  389. {
    

  390.     uart_dam_t *p_uart_dma = &uart1_dma;
    


  391. 

  392.     //获取中断标记并判断否是置位
    

  393.     if(dma_interrupt_flag_get(p_uart_dma->dma_periph, p_uart_dma->dma_channelx, DMA_INT_FLAG_FTF))
    

  394.     {
    

  395.         //清除dma中断标记
    

  396.         dma_interrupt_flag_clear(p_uart_dma->dma_periph, p_uart_dma->dma_channelx, DMA_INT_FLAG_G);
    

  397.         p_uart_dma->dma_or_idle = SET;
    

  398.     }
    


  399. 

  400. }
    

  401. /*串口2 dma*/
    

  402. void DMA0_Channel2_IRQHandler(void)
    

  403. {
    

  404.     uart_dam_t *p_uart_dma = &uart2_dma;
    


  405. 

  406.     //获取中断标记并判断否是置位
    

  407.     if(dma_interrupt_flag_get(p_uart_dma->dma_periph, p_uart_dma->dma_channelx, DMA_INT_FLAG_FTF))
    

  408.     {
    

  409.         //清除dma中断标记
    

  410.         dma_interrupt_flag_clear(p_uart_dma->dma_periph, p_uart_dma->dma_channelx, DMA_INT_FLAG_G);
    

  411.         p_uart_dma->dma_or_idle = SET;
    

  412.     }
    


  413. 

  414. }
    

  415. /*串口3 dma*/
    

  416. void DMA1_Channel2_IRQHandler(void)
    

  417. {
    

  418.     uart_dam_t *p_uart_dma = &uart3_dma;
    


  419. 

  420.     //获取中断标记并判断否是置位
    

  421.     if(dma_interrupt_flag_get(p_uart_dma->dma_periph, p_uart_dma->dma_channelx, DMA_INT_FLAG_FTF))
    

  422.     {
    

  423.         //清除dma中断标记
    

  424.         dma_interrupt_flag_clear(p_uart_dma->dma_periph, p_uart_dma->dma_channelx, DMA_INT_FLAG_G);
    

  425.         p_uart_dma->dma_or_idle = SET;
    

  426.     }
    


  427. 

  428. }
    


  429. 

  430. /*注册一个处理函数*/
    

  431. int bsp_uart_register_handle(uart_dam_t *puart_dma, recv_hanled hanled_fun)
    

  432. {
    


  433. 

  434.     puart_dma->hanled_fun = hanled_fun;
    

  435. }
    


  436. 

  437. //循环调用函数用于处理各个串口数据
    

  438. void bsp_uart_dma_procees(uint32_t tick)
    

  439. {
    

  440.     if(uart0_dma.dma_or_idle)
    

  441.     {
    

  442.         uart_dam_t *puart_dma = &uart0_dma;
    

  443.         puart_dma->dma_or_idle = 0;
    

  444.         puart_dma->hanled_fun(puart_dma->uart_rx_buffers, puart_dma->data_num);
    

  445.         puart_dma->data_num = 0;
    

  446.     }
    

  447.     else if(uart1_dma.dma_or_idle)
    

  448.     {
    

  449.         uart_dam_t *puart_dma = &uart1_dma;
    

  450.         puart_dma->dma_or_idle = 0;
    

  451.         puart_dma->hanled_fun(puart_dma->uart_rx_buffers, puart_dma->data_num);
    

  452.         puart_dma->data_num = 0;
    

  453.     }
    


  454. 

  455.     if(uart2_dma.dma_or_idle)
    

  456.     {
    

  457.         uart_dam_t *puart_dma = &uart2_dma;
    

  458.         puart_dma->dma_or_idle = 0;
    

  459.         puart_dma->hanled_fun(puart_dma->uart_rx_buffers, puart_dma->data_num);
    

  460.         puart_dma->data_num = 0;
    

  461.     }
    


  462. 

  463.     if(uart3_dma.dma_or_idle)
    

  464.     {
    

  465.         uart_dam_t *puart_dma = &uart3_dma;
    

  466.         puart_dma->dma_or_idle = 0;
    

  467.         puart_dma->hanled_fun(puart_dma->uart_rx_buffers, puart_dma->data_num);
    

  468.         puart_dma->data_num = 0;
    

  469.     }
    


  470. 

  471. }
回复

收藏1 举报

 楼主| t61000 发表于 2022-11-18 15:34 | 显示全部楼层
测试
复制
  1. #include "gd32f30x.h"
    

  2. #include "gd32f303_sys.h"
    

  3. #include "systick.h"
    

  4. #include "uart.h"
    

  5. #include "stdio.h"
    

  6. #include "adc.h"
    

  7. #include "button.h"
    

  8. #include "bsp_gpio.h"
    

  9. #include "at24cxx.h"
    


  10. 

  11. void uart0_recv_hanled(uint8_t *data, uint16_t len)
    

  12. {
    

  13.     printf("read len = %d:", len);
    


  14. 

  15.     for(int i = 0; i < len; i++)
    

  16.     {
    

  17.         printf("%02x ", (int)data[i]);
    

  18.     }
    


  19. 

  20.     printf("\r\n");
    

  21. }
    

  22. /*!
    

  23.         主函数：
    

  24. */
    


  25. 

  26. int main(void)
    

  27. {
    


  28. 


  29. 

  30.     /* 配置系统时钟 */
    

  31.     systick_config();
    

  32.     //设置中断分组
    

  33.     nvic_priority_group_set(NVIC_PRIGROUP_PRE2_SUB2);
    

  34.     /* gpio时钟使能*/
    


  35. 

  36.     // 配置MCU调试下载使用swd方式，同时将pb3 和PB4 作为普通gpio
    

  37.     rcu_periph_clock_enable(RCU_AF);
    

  38.     gpio_pin_remap_config(GPIO_SWJ_SWDPENABLE_REMAP, ENABLE);
    

  39.     //gpio
    

  40.     bsp_gpio_init();
    

  41.     //串口初始化
    

  42.     bsp_uart_gpio_rcu_init(USART0);
    

  43.     bsp_uart_usart_base_init(USART0);
    

  44.     //下边是串口的数据接收使用dma方式需要调用和函数
    

  45.     uart_dam_t *uart_dma = init_uart_dma_struct(USART0);
    

  46.     bsp_uart_enable_uart_interrupt(uart_dma);
    

  47.     bsp_uart_dma_nvic_init(uart_dma);
    

  48.     bsp_uart_register_handle(uart_dma, uart0_recv_hanled);
    


  49. 

  50.     // bsp_at24c02_init();
    

  51.     printf("hello gd32\r\n");
    

  52.     //初始化ADC
    

  53. //    adc_init();
    

  54. //    init_btn();
    


  55. 

  56.     BEEP = 0;
    


  57. 

  58.     while(1)
    

  59.     {
    

  60.         if(tick % 500 == 0)
    

  61.         {
    

  62.             LED0 = !LED0;
    

  63.             LED1 = !LED1;
    

  64.             LED2 = !LED2;
    

  65.         }
    


  66. 

  67.         //循环调用
    

  68.         bsp_uart_dma_procees(tick);
    


  69. 


  70. 

  71.     }
    


  72. 

  73. }
    


  74.
回复

收藏1 举报

 楼主| t61000 发表于 2022-11-18 15:42 | 显示全部楼层
8093063773759a9b65.png
回复

收藏1 举报

 楼主| t61000 发表于 2022-11-18 15:42 | 显示全部楼层
# 测试图
817956377377c363d7.png
回复

收藏1 举报

chenqianqian 发表于 2022-11-19 10:57 来自手机 | 显示全部楼层
这样发帖，不方便阅读啊。
回复

收藏1 举报

daichaodai 发表于 2022-11-19 17:41 来自手机 | 显示全部楼层
用中断发送和接受数据，效率更高。
回复

收藏1 举报

tpgf 发表于 2022-12-7 13:51 | 显示全部楼层
每个数据包之间应该都有多长时间的空闲时间呢
回复

收藏1 举报

磨砂 发表于 2022-12-7 14:17 | 显示全部楼层
如何在这种情况下测试丢包数据情况呢
回复

收藏1 举报

晓伍 发表于 2022-12-7 14:38 | 显示全部楼层
确实轮询太浪费资源 使用中断接收就会好很多
回复

收藏1 举报

八层楼 发表于 2022-12-7 14:53 | 显示全部楼层
目前定时的间隔是多少呀  感觉时间准吗
回复

收藏1 举报

观海 发表于 2022-12-7 15:17 | 显示全部楼层
看代码 貌似楼主启用了dma是吗  如果代码非常简单的话  使用dma会不会反而复杂化呢
回复

收藏1 举报

观海 发表于 2022-12-7 15:20 | 显示全部楼层
当出现串口堵塞的时候 一般如何处理呢
回复

收藏1 举报

guanjiaer 发表于 2022-12-7 15:37 | 显示全部楼层
感觉过程处理的有点复杂了  其实流程还是很简单的
回复

收藏1 举报

vivilyly 发表于 2022-12-11 17:56 | 显示全部楼层
可以使用DMA的方式进行数据的传输的吗？
回复

收藏1 举报

louliana 发表于 2022-12-12 10:44 | 显示全部楼层
串口的空闲字符是用来激活空闲中断的吗
回复

收藏1 举报

jkl21 发表于 2022-12-12 11:41 | 显示全部楼层
GD32F103有空闲中断的吗？
回复

收藏1 举报

elsaflower 发表于 2022-12-12 12:12 | 显示全部楼层
串口通信数据连续性,该怎么处理？   
回复

收藏1 举报

janewood 发表于 2022-12-12 12:52 | 显示全部楼层
串口接收比较好的处理方式了吗？              
回复

收藏1 举报

houjiakai 发表于 2022-12-12 13:41 | 显示全部楼层
串口中断接收程序,怎样一次性接受多个字符?  
回复

收藏1 举报

下一页 »
12下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

t61000

19

主题

124

帖子

0

粉丝
快速回复 在线客服 返回列表 返回顶部