当前位置： 首页 > news >正文

【2】GD32H7xx 串口Idle + DMA接收不定长数据

news 2024/11/17 17:37:27

目录

  • 1. IDLE中断相关介绍
  • 2. D-Cache与DMA同时使用
    • 2.1 I-Cache与D-Cache
    • 2.2 D-Cache与DMA同时使用时的数据一致性问题
      • 2.2.1 CPU读取DMA写入到SRAM的数据
      • 2.2.2 DMA读取CPU写入到SRAM的数据
  • 3. Uart Idle + DMA收发程序
  • 4. 程序测试

1. IDLE中断相关介绍

在 GD32H7xx MCU 中，串口的 Idle 中断检测机制如下：
  首先，当有数据开始被接收时，串口的接收数据寄存器非空（RXNE 位被置位），此时开始启动对空闲状态的检测。从检测到有数据接收这一刻起，串口会持续监测数据总线。如果在接下来一个字节对应的传输周期内，总线上都没有新的数据被接收，串口的硬件逻辑就会将空闲中断标志位（IDLE 位）置 1，从而触发空闲中断。
  需要注意的是，空闲中断标志位（IDLE 位）并非在空闲期间一直保持置 1 的状态。另外，空闲中断标志位（IDLE 位）不会被硬件自动清零。在系统响应中断后，需要在中断服务程序中通过软件手动将其清零，以便为下一次的空闲检测做好准备。
这样的机制能够准确且高效地检测到串口数据接收的空闲状态，尤其适用于处理不定长的数据接收，为系统提供了及时处理接收数据的时机。

  串口Idle + DMA 收发数据的优势：

  • 高效性：DMA 可以在后台自动完成数据从串口缓冲区到内存的传输，无需 CPU 频繁参与，释放 CPU 资源用于其他重要任务。
  • 实时性：通过 Idle 中断能及时检测到一帧数据接收完毕，迅速进行处理，减少数据处理的延迟。
  • 降低 CPU 负载：CPU 不必一直监控串口状态和进行数据搬移，专注于核心业务逻辑。
  • 处理不定长数据：由于能在 Idle 中断时确定一帧数据结束，所以适合接收长度不固定的数据，提高了系统对不同数据格式的适应性。
  • 稳定性：减少了由于 CPU 繁忙导致的数据丢失或处理不及时的风险。

2. D-Cache与DMA同时使用

2.1 I-Cache与D-Cache

  GD32H7 MCU 中的 I-Cache（Instruction Cache，指令缓存）和 D-Cache（Data Cache，数据缓存）具有以下特点和作用：

  • I-Cache（指令缓存）：
    • 加速指令获取：存储最近使用的指令，减少从较慢的主存储器（如闪存）中获取指令的次数，从而提高 CPU 取指的速度，提升程序执行效率。
    • 提高系统性能：有助于减少指令访问的延迟，使 CPU 能够更快地获取下一条要执行的指令，尤其在处理复杂和大型程序时效果显著。
  • D-Cache（数据缓存）：
    • 数据暂存：用于缓存经常访问的数据，避免频繁从主存读取数据，加快数据访问速度。
    • 优化数据读写：提高数据读写的局部性，减少对主存的访问，降低数据访问的功耗和延迟。

  当CPU读取指令或数据时，CPU首先将访问地址发送到I-Cache或D-Cache进行比对，如果比对匹配，则说明数据在I-Cache或D-Cache中，然后CPU直接从I-Cache或D-Cache中取出数据并继续执行指令或访问数据。如果比对不匹配，则说明数据不在I-Cache或D-Cache中，此时CPU就会从主存储器中读取数据。GD32H7xx的I-Cache和D-Cache大小都是32KB。
  这两种缓存的存在有助于提高 GD32H7 MCU 的整体性能，使其能够更高效地处理各种任务，特别是在对实时性和性能要求较高的应用场景中具有重要意义。然而，在某些特殊应用中，可能需要对缓存进行精细的管理和控制，以确保数据的一致性和准确性。

2.2 D-Cache与DMA同时使用时的数据一致性问题

  GD32H7xx 在Cache未命中时将为数据分配高速缓存行，将32字节数据从主存储器存放至Cache，后续访问这些主存储器地址时，Cache会被命中，直接从Cache中读取数据。当SRAM上启用了Cache时，CPU和DMA同时访问SRAM会存在一致性问题。

2.2.1 CPU读取DMA写入到SRAM的数据

  当DMA从外设读取数据并更新到SRAM中的接收缓冲区recv_buf[ ]时,此时CPU尝试读取recv_buf[ ]，读取到的是Cache中缓存的数据，而不是SRAM中的新数据。
解决方式：
1.在DMA接收数据完成之后，对Cache中的recv_buf[ ]进行无效操作。执行Cache无效操作后使得Cache中的recv_buf[ ]无效，CPU在尝试读取recv_buf[ ]时，Cache不会命中。

// destination : DMA接收buffer
// RECV_BUF_SIZE： DMA接收buffer size
SCB_InvalidateDCache_by_Addr ((uint32_t *)recv_buf, RECV_BUF_SIZE);

2.为保证Cache line 边界对齐，recv_buf[ ]的大小必须是32字节对齐

__attribute__ ((aligned(32))) uint8_t recv_buf[RECV_BUF_SIZE];

2.2.2 DMA读取CPU写入到SRAM的数据

  当CPU在更新传输缓冲区send_buf[ ]中要待传输数据时，将仅更新Cache中数据而不会更新SRAM中的数据，当DMA读取send_buf[ ]中数据时，会从SRAM中读取，而不是CPU更新的Cache中的新数据。
解决方式：
1.在启动DMA传输之前，执行Cache清理操作，将Cache中send_buf[ ]刷新到SRAM中。

SCB_CleanDCache_by_Addr((uint32_t*)send_buf, SEND_BUF_SIZE); // cache 清理

2.send_buf[ ]的大小必须是32字节对齐

__attribute__ ((aligned(32))) uint8_t send_buf[SEND_BUF_SIZE];

3. Uart Idle + DMA收发程序

#define UART7_RDATA_ADDRESS      (&USART_RDATA(UART7))
#define UART7_TDATA_ADDRESS      (&USART_TDATA(UART7))
#define ARRAYNUM(arr_nanme)       (uint32_t)(sizeof(arr_nanme) / sizeof(*(arr_nanme)))#define UART7_DMA_TX_BUF_LEN	64
#define UART7_DMA_RX_BUF_LEN	128__attribute__ ((aligned(32))) uint8_t txbuffer[UART7_DMA_TX_BUF_LEN];
__attribute__ ((aligned(32))) uint8_t rxbuffer[UART7_DMA_RX_BUF_LEN];osSemaphoreId_t uart7_rx_sem;	
osSemaphoreId_t uart7_tx_sem;	
uint8_t g_uart7_rx_len;// 信号量属性
const osSemaphoreAttr_t uart7_rx_sem_attr = 
{.name = "uart7_rx_sem",
};// 信号量属性
const osSemaphoreAttr_t uart7_tx_sem_attr = 
{.name = "uart7_tx_sem",
};/*\brief      enable uart7 rx\param[in]  none\retval		none
*/
static void uart7_rx_en(void)
{dma_single_data_parameter_struct dma_init_struct;dma_deinit(DMA0, DMA_CH1);dma_single_data_para_struct_init(&dma_init_struct);dma_init_struct.request 	 = DMA_REQUEST_UART7_RX;dma_init_struct.direction	 = DMA_PERIPH_TO_MEMORY;dma_init_struct.memory0_addr  = (uint32_t)rxbuffer;dma_init_struct.memory_inc	 = DMA_MEMORY_INCREASE_ENABLE;dma_init_struct.periph_memory_width = DMA_PERIPH_WIDTH_8BIT;dma_init_struct.number		 = UART7_DMA_RX_BUF_LEN;dma_init_struct.periph_addr  = (uint32_t)UART7_RDATA_ADDRESS;dma_init_struct.periph_inc	 = DMA_PERIPH_INCREASE_DISABLE;dma_init_struct.priority	 = DMA_PRIORITY_ULTRA_HIGH;dma_single_data_mode_init(DMA0, DMA_CH1, &dma_init_struct);dma_circulation_disable(DMA0, DMA_CH1);usart_dma_receive_config(UART7, USART_RECEIVE_DMA_ENABLE);dma_interrupt_enable(DMA0, DMA_CH1, DMA_INT_FTF);dma_channel_enable(DMA0, DMA_CH1);}/*\brief      disable uart7 rx\param[in]  none\retval		none
*/
static void uart7_rx_dis(void)
{dma_channel_disable(DMA0,DMA_CH1);
}/*\brief      DMA0 Channel0 IRQ Handle\param[in]  none\retval		none
*/
void DMA0_Channel0_IRQHandler(void)
{if (RESET != dma_interrupt_flag_get(DMA0, DMA_CH0, DMA_INT_FLAG_FTF)) {dma_interrupt_flag_clear(DMA0, DMA_CH0, DMA_INT_FLAG_FTF);dma_channel_disable(DMA0,DMA_CH0);	//LogI("DMA0_Channel0_IRQHandler tx finish\r\n");}
}/*\brief      DMA0 Channel1 IRQ Handle\param[in]  none\retval		none本例子中没有用到这个中断
*/
void DMA0_Channel1_IRQHandler(void)
{//LogI("DMA0_Channel1_IRQHandler\r\n");if (RESET != dma_interrupt_flag_get(DMA0, DMA_CH1, DMA_INT_FLAG_FTF)) {dma_interrupt_flag_clear(DMA0, DMA_CH1, DMA_INT_FLAG_FTF);//memcpy(txbuffer, rxbuffer, 32);//usart_transmit_dma(txbuffer, 32);/*dma_single_data_parameter_struct dma_init_struct;dma_deinit(DMA0, DMA_CH1);dma_single_data_para_struct_init(&dma_init_struct);dma_init_struct.request      = DMA_REQUEST_UART7_RX;dma_init_struct.direction    = DMA_PERIPH_TO_MEMORY;dma_init_struct.memory0_addr  = (uint32_t)rxbuffer;dma_init_struct.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;dma_init_struct.periph_memory_width = DMA_PERIPH_WIDTH_8BIT;dma_init_struct.number       = 32;dma_init_struct.periph_addr  = (uint32_t)(&USART_RDATA(UART7));dma_init_struct.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;dma_init_struct.priority     = DMA_PRIORITY_ULTRA_HIGH;dma_single_data_mode_init(DMA0, DMA_CH1, &dma_init_struct);dma_circulation_disable(DMA0, DMA_CH1);usart_dma_receive_config(UART7, USART_RECEIVE_DMA_ENABLE);dma_interrupt_enable(DMA0, DMA_CH1, DMA_INT_FTF);dma_channel_enable(DMA0, DMA_CH1);*/}
}/*\brief      UART7 IRQ Handle\param[in]  none\retval		none
*/
void UART7_IRQHandler()
{uart7_rx_dis();if (RESET != usart_interrupt_flag_get(UART7, USART_INT_FLAG_IDLE)) {usart_interrupt_flag_clear(UART7, USART_INT_FLAG_IDLE);LogI("USART_INT_FLAG_IDLE\r\n");uint16_t remian_len, len;remian_len = dma_transfer_number_get(DMA0,DMA_CH1);len = UART7_DMA_RX_BUF_LEN - remian_len;  //本次收到的数据长度LogI("recv len = %d ; remian_len = %d\r\n", len, remian_len);SCB_InvalidateDCache_by_Addr ((uint32_t *)rxbuffer, UART7_DMA_RX_BUF_LEN); // 对cache中rxbuffer无效if(len > 0){g_uart7_rx_len = len;osSemaphoreRelease(uart7_rx_sem);}}uart7_rx_en();
}void uart7_init(void)
{rcu_periph_clock_enable(RCU_GPIOE);rcu_periph_clock_enable(RCU_UART7);nvic_irq_enable(UART7_IRQn, 2, 0);gpio_af_set(GPIOE, GPIO_AF_8, GPIO_PIN_0);gpio_af_set(GPIOE, GPIO_AF_8, GPIO_PIN_1);gpio_mode_set(GPIOE, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_0);gpio_output_options_set(GPIOE, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_0);gpio_mode_set(GPIOE, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_1);gpio_output_options_set(GPIOE, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_1);usart_deinit(UART7);usart_word_length_set(UART7, USART_WL_8BIT);usart_stop_bit_set(UART7, USART_STB_1BIT);usart_parity_config(UART7, USART_PM_NONE);usart_baudrate_set(UART7, 115200U);usart_flag_clear(UART7, USART_FLAG_IDLE);usart_transmit_config(UART7, USART_TRANSMIT_ENABLE);usart_receive_config(UART7, USART_RECEIVE_ENABLE);usart_interrupt_enable(UART7, USART_INT_IDLE);usart_enable(UART7);
}/*\brief      uart7_dma_send\param[in]  buf: send data\param[in]	len: data len\retval		none
*/
void uart7_dma_send(char* buff, int size)
{memcpy(txbuffer, buff, size);SCB_CleanDCache_by_Addr((uint32_t*)txbuffer, size); // cache 清理dma_memory_address_config(DMA0, DMA_CH0, DMA_MEMORY_0, (uint32_t)txbuffer);dma_transfer_number_config(DMA0, DMA_CH0, size);LogI("uart7_dma tx len:%d\r\n", size);dma_channel_enable(DMA0, DMA_CH0);
}void usart_transmit(char* buff, int size)
{for (int i = 0; i < size; ++i) {usart_data_transmit(UART7, buff[i]);while (RESET == usart_flag_get(UART7, USART_FLAG_TBE)) {}}
}/*\brief      uart7 dma config\param[in]  none\param[in]	none\retval		none
*/
void uart7_dma_config(void)
{rcu_periph_clock_enable(RCU_DMA0);rcu_periph_clock_enable(RCU_DMAMUX);nvic_irq_enable(DMA0_Channel0_IRQn, 2, 0);//nvic_irq_enable(DMA0_Channel1_IRQn, 2, 1);dma_single_data_parameter_struct dma_init_struct;SCB_CleanDCache_by_Addr((uint32_t*)txbuffer, UART7_DMA_TX_BUF_LEN);//TXdma_deinit(DMA0, DMA_CH0);dma_single_data_para_struct_init(&dma_init_struct);dma_init_struct.request      = DMA_REQUEST_UART7_TX;dma_init_struct.direction    = DMA_MEMORY_TO_PERIPH;dma_init_struct.memory0_addr  = (uint32_t)txbuffer;dma_init_struct.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;dma_init_struct.periph_memory_width = DMA_PERIPH_WIDTH_8BIT;dma_init_struct.periph_addr  = (uint32_t)UART7_TDATA_ADDRESS;dma_init_struct.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;dma_init_struct.priority     = DMA_PRIORITY_MEDIUM;dma_single_data_mode_init(DMA0, DMA_CH0, &dma_init_struct);dma_circulation_disable(DMA0, DMA_CH0);usart_dma_transmit_config(UART7, USART_TRANSMIT_DMA_ENABLE);dma_interrupt_enable(DMA0, DMA_CH0, DMA_INT_FTF);//dma_channel_enable(DMA0, DMA_CH0);//RXdma_deinit(DMA0, DMA_CH1);dma_single_data_para_struct_init(&dma_init_struct);dma_init_struct.request      = DMA_REQUEST_UART7_RX;dma_init_struct.direction    = DMA_PERIPH_TO_MEMORY;dma_init_struct.memory0_addr  = (uint32_t)rxbuffer;dma_init_struct.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;dma_init_struct.periph_memory_width = DMA_PERIPH_WIDTH_8BIT;dma_init_struct.number       = UART7_DMA_RX_BUF_LEN;dma_init_struct.periph_addr  = (uint32_t)UART7_RDATA_ADDRESS;dma_init_struct.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;dma_init_struct.priority     = DMA_PRIORITY_ULTRA_HIGH;dma_single_data_mode_init(DMA0, DMA_CH1, &dma_init_struct);dma_circulation_disable(DMA0, DMA_CH1);usart_dma_receive_config(UART7, USART_RECEIVE_DMA_ENABLE);//dma_interrupt_enable(DMA0, DMA_CH1, DMA_INT_FTF);dma_channel_enable(DMA0, DMA_CH1);
}/*\brief      uart7_idle_dma_test_thread\param[in]  none\param[in]	none\retval		none
*/
void uart7_idle_dma_test_thread(void)
{LogI("uart7_idle_dma_test_thread run...\r\n");uint32_t ret;static uint16_t pollcnt = 0;uart7_rx_sem = osSemaphoreNew(2, 0, &uart7_rx_sem_attr);	uart7_init();uart7_dma_config();while(1){ret = osSemaphoreAcquire(uart7_rx_sem, 100);   //等待接收数据if(ret == osErrorTimeout)                          //超时{//LogI("Acquire uart7_rx_sem timeout\r\n");}else{LogI("uart7 recv data:");uint8_t i;for(i=0; i < g_uart7_rx_len; i++){printf("[%d]=%d,", i, rxbuffer[i]);}printf("\r\n");uart7_dma_send((char *)rxbuffer, g_uart7_rx_len);}}}

4. 程序测试

程序功能：通过IDLE中断和串口的DMA收发功能实现将收到的数据再发出去。
经过测试程序功能正常。
在这里插入图片描述

To Be Continue …


http://www.mrgr.cn/news/69164.html

相关文章：

  • C#/WinForm拖拽文件上传
  • AI 写作（九）实战项目二：智能新闻报道（9/10）
  • 微服务中的技术使用与搭配：如何选择合适的工具构建高效的微服务架构
  • Scala入门基础（17.1）Set集习题
  • 什么是量化交易
  • JavaScript高级程序设计基础（四）
  • 【EFK】Linux集群部署Elasticsearch最新版本8.x
  • 2024 年 Java 面试正确姿势（1000+ 面试题附答案解析）
  • 操作系统学习笔记-5.2设备独立性软件
  • 简记Vue3（四）—— 路由
  • SCAU 高级程序设计语言（C语言） 教材习题
  • 算法
  • 栈（Stack）和队列(Deque、Queue)
  • OSPF总结
  • 一键分发平台哪个方式最好？老板一人轻松运营500名员工的实战经验分享！（从零开始，不走弯路！）
  • Linux下通过sqlplus连Oracle提示字符是乱码▒▒▒[
  • 从《梅艳芳》到《焚城》，王丹妮实力诠释剧抛脸
  • leetcode 832.翻转图像
  • [CKS] kube-batch修复不安全项
  • [Python学习日记-63] 继承与派生
  • 算法 -插入排序
  • 从 iPhone 设备恢复误删微信消息的 4 种方法
  • C++ --- 异步编程
  • 一致性哈希算法详解
  • 理想汽车Android面试题及参考答案
  • 本地连接IP地址的自主设置指南‌