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);

    //TX
    dma_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);

    //RX
    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      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 …