小车通过PG8和PG14和鲁班猫通信,对应的就是USART5串口
企业微信截图_16988262273589.png

USART5串口实现

usart5_rt.h

  1. #ifndef UART5_RT_H
  2. #define UART5_RT_H
  4. #include "gd32f4xx.h"
  5. #include "systick.h"
  6. #include "stdio.h"
  7. #include "string.h"
  9. extern float speed[3];
  11. //RX和TX引脚时钟
  12. #define USART_TX_RX_RCU       RCU_GPIOG
  13. //USART0时钟
  14. #define USART_RCU             RCU_USART5
  16. //引脚类型
  17. #define USART_GPIO      GPIOG
  18. //引脚编号
  19. #define USART_RX_PIN GPIO_PIN_9
  20. #define USART_TX_PIN GPIO_PIN_14
  22. //复用编号
  23. #define RX_ALT_NUM GPIO_AF_8
  24. #define TX_ALT_NUM GPIO_AF_8
  26. //USART编号
  27. #define USART_NUM USART5
  28. //USART中断配置
  29. #define NVIC_IRQ USART5_IRQn
  31. //USART0的DMA时钟
  32. #define BSP_DMA_RCU RCU_DMA1
  33. #define BSP_DMA DMA1
  34. #define BSP_DMA_CHANNEL_RX DMA_CH1
  35. #define BSP_DMA_CHANNEL_TX DMA_CH6
  37. //DMA外部连接
  38. #define RX_DMA_SUBPERIPHERAL_ENUM DMA_SUBPERI5
  39. #define TX_DMA_SUBPERIPHERAL_ENUM DMA_SUBPERI5
  41. //USART关于GPIO配置
  42. void usart5_gpio_config(void);
  44. //USART关于参数配置
  45. void usart5_param_config(uint32_t baudval);
  46. //DMA发送配置
  47. int32_t usart5_dma_tx_init(uint32_t periph_addr);
  49. //USART接收的dma配置
  50. int32_t usart5_dma_rx_init(uint32_t periph_addr);
  52. //包含gpio和usart参数配置
  53. void usart5_dma_config(uint32_t baudval);
  54. //通过DMA发送
  55. int32_t uart5_dma_send(uint8_t *data,uint32_t len);
  56. //解析速度
  57. void parse_speed(void);
  59. #endif

usart5_rt.c

  1. #include "uart5_rt.h"
  3. //uint8_t g_send_data[256];//发送数据
  4. uint8_t temp5[1] = {0};
  5. //接收数据最终存放位置
  6. uint8_t g5_recv_data[256];//接收数据
  8. //x y及z的线速度
  9. float speed[3] = {0.0};
  12. void usart5_gpio_config(void){
  13. //    ● 开启时钟（包括串口时钟和GPIO时钟）
  14.     rcu_periph_clock_enable(USART_TX_RX_RCU);
  15.     rcu_periph_clock_enable(USART_RCU);
  16. //    ● 配置GPIO复用模式
  17.     gpio_af_set(USART_GPIO,RX_ALT_NUM,USART_RX_PIN);
  18.     gpio_af_set(USART_GPIO,TX_ALT_NUM,USART_TX_PIN);
  19. //    ● 配置GPIO的模式
  20.     gpio_mode_set(USART_GPIO,GPIO_MODE_AF,GPIO_PUPD_PULLUP,USART_RX_PIN);
  21.     gpio_mode_set(USART_GPIO,GPIO_MODE_AF,GPIO_PUPD_PULLUP,USART_TX_PIN);
  22. //    ● 配置GPIO的输出
  23.     /* 配置TX为推挽输出 50MHZ */
  24.     gpio_output_options_set(USART_GPIO, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, USART_RX_PIN);
  25. /* 配置RX为推挽输出 50MHZ */
  26.     gpio_output_options_set(USART_GPIO, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, USART_TX_PIN);
  27. }
  30. void usart5_param_config(uint32_t baudval){
  31.     //USART复位
  32.     usart_deinit(USART_NUM);
  33.     //波特率
  34.     usart_baudrate_set(USART_NUM,baudval);
  35.     //校验位
  36.     usart_parity_config(USART_NUM,USART_PM_NONE);
  37.     //一个周期发送的数据位数
  38.     usart_word_length_set(USART_NUM,USART_WL_8BIT);
  39.     //停止位
  40.     usart_stop_bit_set(USART_NUM,USART_STB_1BIT);
  41.     //先发送高位还是低位
  42.     usart_data_first_config(USART_NUM,USART_MSBF_LSB);
  45.     //串口使能
  46.     usart_enable(USART_NUM);
  47.     //发送功能配置
  48.     usart_transmit_config(USART_NUM,USART_TRANSMIT_ENABLE);
  49.     //接收配置
  50.     usart_receive_config(USART_NUM,USART_RECEIVE_ENABLE);
  51.     //接收中断配置
  52.     nvic_irq_enable(NVIC_IRQ, 2, 2);
  53.     //配置处理哪些中断
  54.     //USART_INT_RBNE:接收到一个字符就会触发,需要保存接收的字符
  55.     usart_interrupt_enable(USART_NUM, USART_INT_RBNE); // 读数据缓冲区非空中断和过载错误中断 
  56.     //USART_INT_IDLE:一帧数据接收完成 hello 可以打印对应的字符串
  57.     usart_interrupt_enable(USART_NUM, USART_INT_IDLE); // DLE线检测中断
  59.     /* 使能串口DMA发送 */
  60.     usart_dma_transmit_config(USART_NUM, USART_TRANSMIT_DMA_ENABLE);
  63.     /* 使能串口DMA接收 */
  64.     usart_dma_receive_config(USART_NUM, USART_RECEIVE_DMA_ENABLE);
  65.         //接收中断配置
  66.     nvic_irq_enable(NVIC_IRQ, 2, 2);
  67.     //USART_INT_IDLE:一帧数据接收完成 hello 可以打印对应的字符串
  68.     usart_interrupt_enable(USART_NUM, USART_INT_IDLE); // DLE线检测中断
  69. }
  71. int32_t usart5_dma_tx_init(uint32_t periph_addr)
  72. {
  73.     /* 使能DMA时钟 */
  74.     rcu_periph_clock_enable(BSP_DMA_RCU);
  75.     /* 复位DMA并禁用DMA传输 */
  76.     dma_deinit(BSP_DMA, BSP_DMA_CHANNEL_TX);
  77.     /* 配置DMA传输结构体 */
  78.     dma_single_data_parameter_struct dma_init_struct;
  79.     //DMA传输方向：从内存到外设
  80.     dma_init_struct.direction = DMA_MEMORY_TO_PERIPH;   
  81.     //传输数据的内存地址
  82. //    dma_init_struct.memory0_addr = (uint32_t)g_send_data;   
  83.     //内存地址递增
  84.     dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE; 
  85.     //传输数据的大小  
  86. //    dma_init_struct.number = sizeof(g_send_data);   
  87.     //外设地址
  88.     dma_init_struct.periph_addr = periph_addr; 
  89.     //外设地址不递增
  90.     dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;   
  91.     //外设地址的数据宽度为8位
  92.     dma_init_struct.periph_memory_width = DMA_PERIPH_WIDTH_8BIT; 
  93.     //DMA传输优先级为最高
  94.     dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
  95.     /* 禁止DMA传输循环模式 */
  96.     dma_init_struct.circular_mode = DMA_CIRCULAR_MODE_DISABLE;
  97.     /* 初始化DMA传输 */
  98.     dma_single_data_mode_init(BSP_DMA, BSP_DMA_CHANNEL_TX, &dma_init_struct);
  100.     /* 配置DMA通道的外设连接 */
  101.     dma_channel_subperipheral_select(BSP_DMA, BSP_DMA_CHANNEL_TX, TX_DMA_SUBPERIPHERAL_ENUM);
  102.     return 0;
  103. }
  105. //USART接收的dma配置
  106. int32_t usart5_dma_rx_init(uint32_t periph_addr)
  107. {
  108.     /* 使能DMA时钟 */
  109.     rcu_periph_clock_enable(BSP_DMA_RCU);
  110.     /* 复位DMA并禁用DMA传输 */
  111.     dma_deinit(BSP_DMA, BSP_DMA_CHANNEL_RX);
  112.     /* 配置DMA传输结构体 */
  113.     dma_single_data_parameter_struct dma_parameter;
  114.     // DMA传输方向：从外设到内存
  115.     dma_parameter.direction = DMA_PERIPH_TO_MEMORY;  
  116.     // 外设地址，指向要接收数据的外设寄存器地址
  117.     dma_parameter.periph_addr = periph_addr;
  118.     // 外设地址不递增    
  119.     dma_parameter.periph_inc = DMA_PERIPH_INCREASE_DISABLE;  
  120.     // 外设地址的数据宽度为8位
  121.     dma_parameter.periph_memory_width = DMA_PERIPH_WIDTH_8BIT;
  122.     // 传输数据的内存地址，指向接收数据的缓存区
  123.     dma_parameter.memory0_addr = (uint32_t)g5_recv_data;  
  124.     // 内存地址递增
  125.     dma_parameter.memory_inc = DMA_MEMORY_INCREASE_ENABLE; 
  126.     // 传输数据的大小，单位为字节    
  127.     dma_parameter.number = sizeof(g5_recv_data);  
  128.     // DMA传输优先级为最高
  129.     dma_parameter.priority = DMA_PRIORITY_ULTRA_HIGH;  
  130.     // 非循环传输模式
  131.     dma_parameter.circular_mode = DMA_CIRCULAR_MODE_DISABLE;  
  133.     dma_single_data_mode_init(BSP_DMA, BSP_DMA_CHANNEL_RX, &dma_parameter);
  134.     /* 配置DMA通道的外设连接 */
  135.     dma_channel_subperipheral_select(BSP_DMA, BSP_DMA_CHANNEL_RX, RX_DMA_SUBPERIPHERAL_ENUM);
  136.     /* 使能DMA传输 */
  137.     dma_channel_enable(BSP_DMA, BSP_DMA_CHANNEL_RX);
  138.     //9.配置中断优先级
  139.     //nvic_irq_enable(DMA1_Channel2_IRQn, 2, 2); 
  140. //    //8.使能DMA通道中断
  141. //    dma_interrupt_enable(BSP_DMA,BSP_DMA_CHANNEL_RX,DMA_CHXCTL_FTFIE);
  142. //    
  143.     dma_interrupt_flag_clear(BSP_DMA,BSP_DMA_CHANNEL_RX,DMA_INT_FLAG_FTF);    
  144.     return 0;
  145. }
  149. /**
  150.   * @brief  调试信息发送接口
  151.   * @param  data：调试数据指针；\
  152.   *            len：调试数据的数据长度
  153.   * @retval 0或其他错误代码
  154.  **/
  155. int32_t uart5_dma_send(uint8_t *data,uint32_t len) 
  156. {
  157.     /* 关闭DMA通道 */
  158.     dma_channel_disable(BSP_DMA, BSP_DMA_CHANNEL_TX);
  159.     /* 清除DMA传输完成标志 */
  160.     dma_flag_clear(BSP_DMA, BSP_DMA_CHANNEL_TX, DMA_FLAG_FTF);
  161.     /* 配置DMA传输的内存地址和传输数据大小 */
  162.     dma_memory_address_config(BSP_DMA, BSP_DMA_CHANNEL_TX, DMA_MEMORY_0, (uint32_t)data);
  163.     dma_transfer_number_config(BSP_DMA, BSP_DMA_CHANNEL_TX, len);
  164.     /* 使能DMA通道 */
  165.     dma_channel_enable(BSP_DMA, BSP_DMA_CHANNEL_TX);
  166.     return 0;
  167. }
  168. //解析速度数据
  169. void parse_speed(void){
  170.         //解析的位数
  171.         int i = 0;
  172.         //帧头数据是否已经解析
  173.     int head = -1;
  174.     //任务类型
  175.     int type = -1;
  176.     //数据长度
  177.     int length = -1;
  178.     //已经读取的数据长度
  179.     int read_length = 0;
  180.         //校验位
  181.         float check = -1; 
  182.         while(1){
  183.             //走到下一位进行
  185.             int8_t data = g5_recv_data[i];
  186.             /*------------------ 读取帧头数据 ------------------*/
  187.             if(head==-1&&data!=0x7b){
  188.                 break;
  189.             }
  190.             if (head==-1&&data == 0x7b) {
  191.                     printf("recv head\n");
  192.                     head = 1;
  193.                     i++;
  194.                     continue;
  195.             }
  196.             /*------------------ 读取类型type ------------------*/
  197.             if (type == -1) {
  198.                     //标识
  199.                     type = data;
  200.                     printf("recv type type=%d\n", type);
  201.                     i++;
  202.                     continue;
  203.             }
  205.             /*------------------ 读取数据长度 ------------------*/
  206.             if (length == -1) {
  207.                     length = data;
  208.                     printf("recv length length=%d\n", length);
  209.                     i++;
  210.                     continue;
  211.             }
  212.             /*------------------ 读取数据 ------------------*/
  213.             printf("-------------------- length=%d\n", length);
  214.             //读取数据
  215.             if (read_length < length) {
  216.                     printf("recv mini data\n");
  217.                     memcpy(&speed[read_length],&g5_recv_data[i],4);
  218.                     read_length += 1;
  219.                     i+=4;
  220.                     continue;
  221.             }
  222.             /*------------------ 验证数据结果是否正确 ------------------*/
  223.             //校验位
  224.             float check = 0.0;
  225.             memcpy(&check,&g5_recv_data[i],4);
  226.             printf("check:%f\n",check);
  228.             float total = 0;
  229.             total += type;
  230.             total += length;
  231.             for (int i = 0; i < length; ++i) {
  232.                     total += speed[i];
  233.             }
  234.             printf("total:%f\n", total);
  235.             if(check!=total){
  236.                 break;
  237.             }
  239.             i+=4;
  240.             printf("i=%d\n",i);
  241.             int8_t tail = 0;
  242.             memcpy(&tail,&g5_recv_data[i],1);
  243.             printf("tail:%d\n",tail);
  244.             break;
  245.         }
  246. }
  248. //USART接收完成中断处理函数
  249. void USART5_IRQHandler(void)
  250. {    
  251.         //printf("usart idle\n");
  252.     uint32_t recv_len = 0;
  253.     if (usart_interrupt_flag_get(USART_NUM, USART_INT_FLAG_IDLE) != RESET)
  254.     {
  255.         /* 清除串口空闲中断标志 */
  256.         usart_interrupt_flag_clear(USART_NUM, USART_INT_FLAG_IDLE);
  257.         //清空缓冲区
  258.                 usart_data_receive(USART_NUM);
  260.         /* 关闭 DMA 接收通道 */
  261.         dma_channel_disable(BSP_DMA, BSP_DMA_CHANNEL_RX);
  263.         /* 获取接收到的数据长度 256 */
  264.         recv_len = sizeof(g5_recv_data) - dma_transfer_number_get(BSP_DMA, BSP_DMA_CHANNEL_RX);
  265.                 printf("recv_len:%d\n",recv_len);
  266.         if (recv_len != 0 && recv_len < sizeof(g5_recv_data))
  267.         {
  268.             /* 将接收到的数据用 DMA 传输发送出去 hello\0*/
  269.             //g6_recv_data[recv_len] = '\0';
  270.             //printf("%s\n",g5_recv_data);
  271.             //解析速度数据
  272.             parse_speed();
  273.             //TODO 需要操作小车移动
  274.             printf("x:%f,y:%f,z:%f\n",speed[0],speed[1],speed[2]);
  275.             /* 配置 DMA 接收传输的内存地址和传输数据大小 */
  276. //            dma_memory_address_config(BSP_DMA, BSP_DMA_CHANNEL_RX, DMA_MEMORY_0, (uint32_t)g6_recv_data);
  277. //            dma_transfer_number_config(BSP_DMA, BSP_DMA_CHANNEL_RX, sizeof(g6_recv_data));
  278.                         //清除DMA传输完成标志位，以便下一次DMA传输能够正常进行
  279.             dma_flag_clear(BSP_DMA, BSP_DMA_CHANNEL_RX, DMA_FLAG_FTF);
  280.             /* 重新开启 DMA 接收通道 */
  281.             dma_channel_enable(BSP_DMA, BSP_DMA_CHANNEL_RX);        
  282.         }else{
  283.             memset(g5_recv_data, 0, sizeof(g5_recv_data));
  284.         }
  285.     }
  286.     return;
  287. }
  289. //全部初始化
  290. void usart5_dma_config(uint32_t baudval){
  291.     //gpio初始化
  292.     usart5_gpio_config();
  293.     //usart参数配置
  294.     usart5_param_config(baudval);
  295.     //USART通过DMA发送配置
  296.     usart5_dma_tx_init((uint32_t)(&USART_DATA(USART_NUM)));
  297.     //USART通过DMA接收配置
  298.     usart5_dma_rx_init((uint32_t)(&USART_DATA(USART_NUM)));
  299. }