首页 > 其他分享 >【2】GD32H7xx 串口Idle + DMA接收不定长数据

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

时间：2024-11-09 13:44:58浏览次数：3  
标签：DMA struct dma GD32H7xx init DMA0 UART7 串口

目录

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 …

标签：DMA,struct,dma,GD32H7xx,init,DMA0,UART7,串口
From： https://blog.csdn.net/madao1234/article/details/143430955

相关文章

  • DMA（Direct Memory Access，直接内存存取）是一种允许外设直接与计算机内存进行数据交换的
    DMA（直接内存存取）简介DMA（DirectMemoryAccess，直接内存存取）是一种允许外设直接与计算机内存进行数据交换的技术，绕过了CPU的参与。这种机制的优势在于，它能够显著提高数据传输效率，减轻CPU的负担，从而使得计算机能够处理更多的任务和更高的性能要求。在传统的输入输出（I/O）操作中，数据通......
  • 定时器(PWM输出)触发ADC采样(DMA)——STM32CubeMX
    在STM32微控制器中，使用定时器(PWM输出)触发ADC采样是一种常见的应用场景，尤其是在需要精确控制采样时刻和频率的场合。本文将详细介绍如何使用STM32CubeMX配置定时器产生PWM波形，并使用DMA传输ADC采样结果。1.定时器PWM输出配置首先，我们需要在STM32CubeMX中配置定时器以产......
  • 查找串口
    查询串口fromserial.tools.list_portsimportcomports(fromserial.tools.list_ports_windowsimportcomports)print(comports())[<serial.tools.list_ports_common.ListPortInfoobjectat0x0000014FD6B0A8C0>,<serial.tools.list_ports_common.ListPortInfo......
  • 手把手教你学pcie（12.17）--实现一个PCIe设备与用户空间应用程序之间的DMA数据传输
    目录基于PCIe的DMA数据传输项目实例1.环境搭建2.FPGA设计3.驱动开发4.用户空间应用程序开发5.调试6.总结实现一个PCIe设备与用户空间应用程序之间的DMA数据传输。这个例子将包括环境搭建、FPGA设计、驱动开发、用户空间应用程序开发和调试等环节。基于PCIe的D......
  • 学习记录：STM32G431CBU6的多通道ADC采样串口打印(HAL库)
    一配置  二代码uint16_tGet_adc(){//启动ADC1HAL_ADC_Start(&hadc1);//等待ADC转换完成，超时为100msHAL_ADC_PollForConversion(&hadc1,100);//判断ADC是否转换成功if(HAL_IS_BIT_SET(HAL_ADC_GetState(&hadc1),HAL_ADC_STATE_REG_EOC)......
  • STM32 第20章 USART--串口通信3
    时间：2024.10.30参考资料：《零死角玩转STM32》“USART--串口通信”章节 一、学习内容1、串口2345代码移植实现控制串口2-->将串口1的宏修改成串口2的即可1.1串口的宏串口1：//为了方便移植，定义的宏//串口1-USART#defineDEBUG_USARTxUSART1#d......
  • STM32 第20章 USART--串口通信2
    时间：2024.10.29参考资料：《零死角玩转STM32》“USART--串口通信”章节编程是从GPIO输出-使用固件库点亮LED灯的基础上开始一、学习内容1、STM32串口初始化结构体和固件库1.1USART初始化结构体 /***@briefUSARTInitStructuredefinition*/typedef......
  • 通过串口与ModBus硬件设备通信
    探头与变送器前面的文章已经实现了ModBus客户端与服务端和他们之间的通信。但只是软件不够，毕竟传感器是硬件。经过我的了解，一个完整的实现了Modbus协议的，并且通过RS485电缆与电脑交换ModBusRTU报文的Modbus设备，一般由两个部分组成。探头探头就是将物理量转化为电信号的东西......
  • ScriptBasedMapping: Script /etc/hadoop/conf/topology_script-py
    spark-sql初始化时异常spark-sql初始化的突然发现spark返回无法解决hostname的问题，网上检索也是说hosts配置不对，但是检查后确实没有因此猜测hosts问题不对也可能引发该问题，但是其他问题也能存在引发问题的情况，因为发现由于执行etc/hadoop/conf/topology_script-p......
  • STM32 第21章 DMA--直接存储器访问
    时间：2024.10.31-11.2参考资料:《零死角玩转STM32》“DMA--直接存储器访问”章节编程部分的代码基于12-GPIO输出-使用固件库点亮LED灯一、学习内容1、DMA功能框图和DMA初始化结构体1.1DMA功能框图1.1.1DMA简介DMA：DataMemoryAccess,直接存储器访问。和GPIO、串口等一......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99