HC32F460 串口 DMA 发送 接收

最新推荐文章于 2024-04-07 09:22:42 发布
最新推荐文章于 2024-04-07 09:22:42 发布
阅读量5k 收藏 47
点赞数 16
分类专栏： HC32 文章标签： 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34327726/article/details/117387724
版权

HC32F460 DMA TX RX

前言

利用DMA 进行串口读写，主要内容包括：
DMA 通道 *2
串口发送空中断，发送完成中断
串口接收中断，接收超时中断
定时器 （串口接收超时定时器 ）

发送/接收功能 比较

功能触发DMA传输次数DMA中断结束标志
TXTI中断适应接收字节个数DMA传输完成中断发送完成标志中断
RXRI中断无数次DMA块完成中断接收超时中断

接收超时定时器通道选择

默认关系，无法任意选择通道，根据实际使用的串口确认定时器通道

TIMEOUT 计数器采用Timer0 模块的计数器，具体对应关系如下：
USART1：Timer0 Unit1 A 通道
USART2：Timer0 Unit1 B 通道
USART3：Timer0 Unit2 A 通道
USART4：Timer0 Unit2 B 通道

串口初始化

/**
 *******************************************************************************
 ** \brief  Usart_init function of project
 **
 ** \param  None
 **
 ** \retval void
 **
 ******************************************************************************/
void Usart_init(void)
{
    en_result_t enRet = Ok;
    stc_irq_regi_conf_t stcIrqRegiCfg;
	  stc_port_init_t stc_485_RE_PortInit,stc_485_TX_PortInit;
    uint32_t u32Fcg1Periph = PWC_FCG1_PERIPH_USART1 | PWC_FCG1_PERIPH_USART2 | \
                             PWC_FCG1_PERIPH_USART3 | PWC_FCG1_PERIPH_USART4;
    const stc_usart_uart_init_t stcInitCfg = {
        UsartIntClkCkNoOutput,//时钟源可选：内部时钟源(内部波特率生成器生成的时钟)/外部时钟源( CKn管脚输入的时钟)
        UsartClkDiv_1,
        UsartDataBits8,//数据长度可编程:8位/9位
        UsartDataLsbFirst,
        UsartOneStopBit,//停止位可配置：1 位/2位
        UsartParityNone,//校验功能可配置：奇校验/偶校验/无校验
        UsartSampleBit8,
        UsartStartBitFallEdge,
        UsartRtsEnable,
    };

    /* Initialize Timer0 */
    Timer0Init();

	/* Initialize DMA */
    DmaInit();
	DmaInit_Tx();

    /* Enable peripheral clock */
    PWC_Fcg1PeriphClockCmd(u32Fcg1Periph, Enable);

    /* Initialize USART IO */

    PORT_SetFunc(USART_RX_PORT, USART_RX_PIN, USART_RX_FUNC, Disable);
	MEM_ZERO_STRUCT(stc_485_TX_PortInit);
	stc_485_TX_PortInit.enPullUp=Enable;
	PORT_Init(USART_TX_PORT,USART_TX_PIN,&stc_485_TX_PortInit);
    PORT_SetFunc(USART_TX_PORT, USART_TX_PIN, USART_TX_FUNC, Disable);

    /* configuration RS485_RE structure initialization */
    MEM_ZERO_STRUCT(stc_485_RE_PortInit);
    stc_485_RE_PortInit.enPinMode = Pin_Mode_Out;
    PORT_Init(USART_RE_PORT, USART_RE_PIN, &stc_485_RE_PortInit);		
	PORT_ResetBits(USART_RE_PORT, USART_RE_PIN);
		
    /* Initialize UART */
    enRet = USART_UART_Init(USART_CH, &stcInitCfg);
    if (enRet != Ok)
    {
        while (1)
        {
        }
    }

    /* Set baudrate */
    enRet = USART_SetBaudrate(USART_CH, USART_BAUDRATE);
    if (enRet != Ok)
    {
        while (1)
        {
        }
    }

    /* Set USART RX IRQ */
    stcIrqRegiCfg.enIRQn = USART_RI_IRQn;
    stcIrqRegiCfg.pfnCallback = &UsartRxIrqCallback;
    stcIrqRegiCfg.enIntSrc = USART_RI_NUM;
    enIrqRegistration(&stcIrqRegiCfg);
    NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
    NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn);
    NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn);

    /* Set USART RX error IRQ */
    stcIrqRegiCfg.enIRQn = USART_EI_IRQn;
    stcIrqRegiCfg.pfnCallback = &UsartErrIrqCallback;
    stcIrqRegiCfg.enIntSrc = USART_EI_NUM;
    enIrqRegistration(&stcIrqRegiCfg);
    NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
    NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn);
    NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn);

    /* Set USART RX timeout error IRQ */
    stcIrqRegiCfg.enIRQn = USART_RTO_IRQn;
    stcIrqRegiCfg.pfnCallback = &UsartTimeoutIrqCallback;
    stcIrqRegiCfg.enIntSrc = USART_RTO_NUM;
    enIrqRegistration(&stcIrqRegiCfg);
    NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
    NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn);
    NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn);

    /* Set USART TX IRQ */
    stcIrqRegiCfg.enIRQn = USART_TI_IRQn;
    stcIrqRegiCfg.pfnCallback = &UsartTxIrqCallback;
    stcIrqRegiCfg.enIntSrc = USART_TI_NUM;
    enIrqRegistration(&stcIrqRegiCfg);
    NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
    NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn);
    NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn);

    /* Set USART TX complete IRQ */
    stcIrqRegiCfg.enIRQn = USART_TCI_IRQn;
    stcIrqRegiCfg.pfnCallback = &UsartTxCmpltIrqCallback;
    stcIrqRegiCfg.enIntSrc = USART_TCI_NUM;
    enIrqRegistration(&stcIrqRegiCfg);
    NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
    NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn);
    NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn);

    /*Enable RX && RX interupt && timeout interrupt function*/
		USART_FuncCmd(USART_CH, UsartNoiseFilter,Enable);

    USART_FuncCmd(USART_CH, UsartRx, Enable);
    USART_FuncCmd(USART_CH, UsartRxInt, Enable);
    USART_FuncCmd(USART_CH, UsartTimeOut, Enable);
    USART_FuncCmd(USART_CH, UsartTimeOutInt, Enable);
    /*Enable TX && RX && RX interrupt function*/

}

DMA初始化

static void DmaInit(void)
{
    stc_dma_config_t stcDmaInit;
    stc_irq_regi_conf_t stcIrqRegiCfg;

    /* Enable peripheral clock */
    PWC_Fcg0PeriphClockCmd(PWC_FCG0_PERIPH_DMA1 | PWC_FCG0_PERIPH_DMA2,Enable);

    /* Enable DMA. */
    DMA_Cmd(DMA_UNIT,Enable);

    /* Initialize DMA. */
    MEM_ZERO_STRUCT(stcDmaInit);
    stcDmaInit.u16BlockSize = 1u; /* 1 block */
    stcDmaInit.u32SrcAddr = ((uint32_t)(&USART_CH->DR)+2ul); /* Set source address. */
    stcDmaInit.u32DesAddr = (uint32_t)(&m_stcRingBuf.au8Buf);     /* Set destination address. */
    stcDmaInit.stcDmaChCfg.enSrcInc = AddressFix;  /* Set source address mode. */
    stcDmaInit.stcDmaChCfg.enDesInc = AddressIncrease;  /* Set destination address mode. */
    stcDmaInit.stcDmaChCfg.enIntEn = Enable;       /* Enable interrupt. */
    stcDmaInit.stcDmaChCfg.enTrnWidth = Dma8Bit;   /* Set data width 8bit. */
	  stcDmaInit.u16DesRptSize=m_stcRingBuf.u16Capacity;
	
	   /* Disable linked list transfer. */
    stcDmaInit.stcDmaChCfg.enLlpEn = Disable;
		 /* Enable repeat function. */
    stcDmaInit.stcDmaChCfg.enDesRptEn = Enable;
		
    DMA_InitChannel(DMA_UNIT, DMA_CH, &stcDmaInit);

    /* Enable the specified DMA channel. */
    DMA_ChannelCmd(DMA_UNIT, DMA_CH, Enable);

    /* Clear DMA flag. */
    DMA_ClearIrqFlag(DMA_UNIT, DMA_CH, TrnCpltIrq);

    /* Enable peripheral circuit trigger function. */
    PWC_Fcg0PeriphClockCmd(PWC_FCG0_PERIPH_AOS,Enable);

    /* Set DMA trigger source. */
    DMA_SetTriggerSrc(DMA_UNIT, DMA_CH, DMA_TRG_SEL);

    /* Set DMA block transfer complete IRQ */
    stcIrqRegiCfg.enIRQn = DMA_BTC_INT_IRQn;
    stcIrqRegiCfg.pfnCallback = &DmaBtcIrqCallback;
    stcIrqRegiCfg.enIntSrc = DMA_BTC_INT_NUM;
    enIrqRegistration(&stcIrqRegiCfg);
    NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
    NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn);
    NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn);
}
static void DmaInit_Tx(void)
{
    stc_dma_config_t stcDmaInit;
    stc_irq_regi_conf_t stcIrqRegiCfg;

    /* Enable peripheral clock */
    PWC_Fcg0PeriphClockCmd(PWC_FCG0_PERIPH_DMA1 | PWC_FCG0_PERIPH_DMA2,Enable);

    /* Enable DMA. */
    DMA_Cmd(DMA_UNIT_TX,Enable);

    /* Initialize DMA. */
    MEM_ZERO_STRUCT(stcDmaInit);
    stcDmaInit.u16BlockSize = 1u; /* 1 block */
    stcDmaInit.u32SrcAddr =  (uint32_t)(&m_stcTingBuf.au8Buf); /* Set source address. */
    stcDmaInit.u32DesAddr = ((uint32_t)(&USART_CH->DR));     /* Set destination address. */ //TDR
    stcDmaInit.stcDmaChCfg.enSrcInc = AddressIncrease;  /* Set source address mode. */
    stcDmaInit.stcDmaChCfg.enDesInc = AddressFix;  /* Set destination address mode. */
    stcDmaInit.stcDmaChCfg.enIntEn = Enable;       /* Enable interrupt. */
    stcDmaInit.stcDmaChCfg.enTrnWidth = Dma8Bit;   /* Set data width 8bit. */
	  stcDmaInit.u16TransferCnt=11;//根据长度  
    DMA_InitChannel(DMA_UNIT_TX, DMA_CH_TX, &stcDmaInit);

    /* Enable the specified DMA channel. */
    DMA_ChannelCmd(DMA_UNIT_TX, DMA_CH_TX, Enable);

    /* Clear DMA flag. */
    DMA_ClearIrqFlag(DMA_UNIT_TX, DMA_CH_TX, TrnCpltIrq);

    /* Enable peripheral circuit trigger function. */
    PWC_Fcg0PeriphClockCmd(PWC_FCG0_PERIPH_AOS,Enable);

    /* Set DMA trigger source. */
    DMA_SetTriggerSrc(DMA_UNIT_TX, DMA_CH_TX, DMA_TRG_SEL_TX);

    /* Set DMA transfer complete IRQ */
    stcIrqRegiCfg.enIRQn = DMA_BTC_INT_IRQn_TX;
    stcIrqRegiCfg.pfnCallback = &DmaTcIrqCallback_TX;
    stcIrqRegiCfg.enIntSrc = DMA_BTC_INT_NUM_TX;
    enIrqRegistration(&stcIrqRegiCfg);
    NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
    NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn);
    NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn);
}

定时器初始化

/**
 *******************************************************************************
 ** \brief Initliaze Timer0.
 **
 ** \param [in] None
 **
 ** \retval None
 **
 ******************************************************************************/
static void Timer0Init(void)
{
    stc_clk_freq_t stcClkTmp;
    stc_tim0_base_init_t stcTimerCfg;
    stc_tim0_trigger_init_t StcTimer0TrigInit;

    MEM_ZERO_STRUCT(stcClkTmp);
    MEM_ZERO_STRUCT(stcTimerCfg);
    MEM_ZERO_STRUCT(StcTimer0TrigInit);

    /* Timer0 peripheral enable */
    PWC_Fcg2PeriphClockCmd(TMR_FCG_PERIPH, Enable);
    CLK_LrcCmd(Enable);
	
    /* Clear CNTAR register for channel B */
//    TIMER0_WriteCntReg(TMR_UNIT, Tim0_ChannelA, 0u);
    TIMER0_WriteCntReg(TMR_UNIT, Tim0_ChannelB, 0u);

    /* Config register for channel B */
    stcTimerCfg.Tim0_CounterMode = Tim0_Async;
    stcTimerCfg.Tim0_AsyncClockSource = Tim0_LRC;
    stcTimerCfg.Tim0_ClockDivision = Tim0_ClkDiv8;//32/8   =4K   0.25ms
    stcTimerCfg.Tim0_CmpValue = 2;//0.25*2=0.5ms    3.5个字节
    TIMER0_BaseInit(TMR_UNIT, Tim0_ChannelB, &stcTimerCfg);

    /* Clear compare flag */
    TIMER0_ClearFlag(TMR_UNIT, Tim0_ChannelB);

    /* Config timer0 hardware trigger */
    StcTimer0TrigInit.Tim0_InTrigEnable = false;
    StcTimer0TrigInit.Tim0_InTrigClear = true;
    StcTimer0TrigInit.Tim0_InTrigStart = true;
    StcTimer0TrigInit.Tim0_InTrigStop = false;
    TIMER0_HardTriggerInit(TMR_UNIT, Tim0_ChannelB, &StcTimer0TrigInit);
}

串口DMA 发送

en_result_t UART_Transmit_DMA(M4_USART_TypeDef *huart, uint8_t *pData, uint16_t Size)
{
	if(DMA_TxComplete==0)
	{
		  if ((pData == NULL) || (Size == 0U))
    {
      return Error;
    }
      DMA_TxComplete=1;
			DMA_SetSrcAddress (DMA_UNIT_TX,DMA_CH_TX,(uint32_t)pData);
			DMA_SetTransferCnt(DMA_UNIT_TX,DMA_CH_TX, Size);
			PORT_SetBits(USART_RE_PORT, USART_RE_PIN);
			while( PORT_GetBit(USART_RE_PORT, USART_RE_PIN)!=1){}
			DMA_ChannelCmd(DMA_UNIT_TX, DMA_CH_TX, Enable);			
			USART_FuncCmd(huart, UsartTxAndTxEmptyInt, Enable);	
			return Ok;
	}
	  else
  {
    return ErrorNotReady;
  }
}

DMA_TX发送流程图

在这里插入图片描述

发送相关中断

/**
 *******************************************************************************
 ** \brief DMA block transfer complete irq callback function.
 **
 ** \param [in] None
 **
 ** \retval None
 **
 ******************************************************************************/
static void DmaTcIrqCallback_TX(void)
{

	DMA_ClearIrqFlag(DMA_UNIT_TX, DMA_CH_TX, TrnCpltIrq);
    DMA_ChannelCmd(DMA_UNIT_TX, DMA_CH_TX, Disable);
    USART_FuncCmd(USART_CH, UsartTxEmptyInt, Disable);
    USART_FuncCmd(USART_CH, UsartTxCmpltInt, Enable);

}
/**
 *******************************************************************************
 ** \brief USART TX complete irq callback function.
 **
 ** \param [in] None
 **
 ** \retval None
 **
 ******************************************************************************/
static void UsartTxCmpltIrqCallback(void)
{
    USART_FuncCmd(USART_CH, UsartTx, Disable);
    USART_FuncCmd(USART_CH, UsartTxCmpltInt, Disable);
	PORT_ResetBits(USART_RE_PORT, USART_RE_PIN); 
	while( PORT_GetBit(USART_RE_PORT, USART_RE_PIN)!=0){}	
	DMA_TxComplete=0;
}
static void UsartTxIrqCallback(void)
{
//    uint8_t u8Data = 0u;

//    if (Ok == RingBufRead(&m_stcRingBuf, &u8Data))
//    {
//				PORT_SetBits(USART_RE_PORT, USART_RE_PIN);
//        USART_SendData(USART_CH, (uint16_t)u8Data);
			 USART_SendData(USART_CH, 0x55);
//    }
//    if (IS_RING_BUFFER_EMPTY(&m_stcRingBuf))
//    {
//        USART_FuncCmd(USART_CH, UsartTxEmptyInt, Disable);
//        USART_FuncCmd(USART_CH, UsartTxCmpltInt, Enable);
//    }
}

串口DMA 接收

DMA_RX 流程图

在这里插入图片描述

接收相关中断

static void DmaBtcIrqCallback(void)
{
	  DMA_ClearIrqFlag(DMA_UNIT, DMA_CH, BlkTrnCpltIrq);
    RingBufWrite_DMA(&m_stcRingBuf);
}
static void UsartTimeoutIrqCallback(void)//
{
    TIMER0_Cmd(TMR_UNIT, Tim0_ChannelB,Disable);
    USART_ClearStatus(USART_CH, UsartRxTimeOut);
//	  DMA_SetDesAddress(DMA_UNIT, DMA_CH, (uint32_t)(&m_stcRingBuf.au8Buf));//  Reset DesAddress	
	  DMA_RxComplete=1;
}
staroooooolove
关注
  • 16
    点赞
  • 踩
  • 47
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
【华大测评】+串口DMA收发数据
qq_15548761的博客
10-15 4332
串口传输用中断实现的话，要频繁的进入中断函数，这样无疑增加MCU的负担，干扰正常程序的运行，对于一些实时性强的应用，如数字显示应用中，液晶屏显示可能受影响而不能正常显示。用DMA实现串口收发数据，进行数据收发过程中，不需要MCU的干预，由DMA独立完成数据的收发，接收或者发送完成后才进入中断做后续处理，因此MCU使用效率更高。 华大提供的例程中，对于串口DMA收发的应用比较简单，我这里结合以前的经验将串口收发用DMA实现。 使用华大免费提供的DEMO板D的基础上实现，MCU型号是HC32F460，当前例程使
华大MCU(三)：HC32F460实现串口dma发送和中断接收
热门推荐
Zhichao_Zhang的博客
02-05 1万+
hc32f460，dma发送，串口中断接收
华大MCU_HC32F460串口TX发送使用DMA传输遇到的坑
冫Michael的博客
11-24 3443
DAM初始化结构体 DMA： 1 次请求传输 1 个数据块，支持连锁传输功能，可实现 1 次请求传输多个数据块。 数据块最小为 1 个数据，最多可以是 1024 个数据，每个数据的宽度可配置为 8bit，16bit 或 32bit。 /* DMA 初始化结构体: */ typedef struct stc_dma_config { uint16_t u16BlockSize; ///< 设置数据块的大小, 0~1023 （0表
遇到HC32F460低于38400波特率不正常问题解决办法
最新发布
04-07 155
昨天要用31250这个MIDI的波特率发现不正常，于是改了几个波特率，发现正常的38400以上能用，以下就都不能用了，于是百度了解决办法，看得一头懵，但是基本确定是时钟分频问题了。后来我试着加上串口时钟分频命令，没有立竿见影，又换了几个位置才解决。
华大HC32F460 KETA 串口3 DMA接收不定长数据 工程源码 编译通过无错误
04-15
hc32f460 KETA 串口DMA接收工程源码： 接收DMA 发送普通串口，当然也可以自己改成DMA发送
【嵌入式】HC32F460串口接收超时中断+DMA
sinat_33408502的博客
02-17 3325
通过串口接收超时中断或者串口接收超时中断+DMA进行串口接收
华大HC32F460
03-25
华大半导体推出的M4核的HC32F460的32位MCU资料介绍。
5-HC32F460(华大单片机)-串口(基本使用) - 杨奉武 - 博客园1
08-04
1.打开数据手册 3. 用ESP8266+android,制作 4. ESP8266刷AT固件与node 5. 有人WIFI模块使用详解(390 6. (一)基
华大 HC32F460 DMA数据传输实验代码详解
weixin_39226439的博客
03-10 1427
详解HC32F460 DMA数据传输实验代码
HC32F460 Bootloader例程
03-12
基于HC32F460一个简单的BootLoader例程框架，实现了从BootLoader到APP的跳转，APP用户程序更新等基本功能。
华大MCU HC32L130(136)串口DMA接收+高级定时器实现空闲超时接收
04-07
使用华大MCU HC32L130(136)配置串口为DMA接收，通过高级定时器6实现超时空闲帧接收的方式，类似于STM32F103 串口DMA + 空闲中断 实现不定长数据收发。
HC32F460模板工程
07-26
HC32F460模板工程，支持IAR和MDK打开，内涵ADC，GPIO、外部中断、通用GPIO、FLASH读写、串口、定时器和看门狗驱动二次封装，使用方便。
HC32F460Temp_FreeRTOS.rar
08-06
华大单片机HC32F60的FreeRTOS移植代码
HC32F460开发之UART+DMA接收不定长数据
Top0_0lll的博客
11-24 3770
文章目录前言一、原理说明二、使用步骤1.引入库2.读入数据总结 前言 使用hc32平台做产品显示板的开发，主板会通过串口不定时上报设备状态，显示板接收到数据包后，解析并根据主板上报的数据显示设备相应的状态到lcd屏上。关于显示板串口接收这一块，原本打算直接COPY demo例程，串口接收到数据后，进一次中断接收一个字节，一次次下来把整包数据读出来，但是因为考虑到显示板在刷屏过程中，主板可能会上报设备状态，频繁的中断可能会影响刷屏速度。综合考虑，还是打算用上DMA来减少串口中断的次数。 一、原理说明 由
华大半导体HC32F4A0笔记（三），RS485通信，使用串口USART1，DMA接收
cypressxt926的博客
01-28 7302
一、USART的工作频率和波特率 看用户手册一上来就糊涂了，手册里面写的PCLK是什么？翻看手册第4章有关CMU章节。似乎这里说的PCLK就是PCLK1？手册是第一版，纰漏其实蛮多的。 在官方库函数验证了猜测，这里说的PCLK指的就是PCLK1： en_result_t USART_SetBaudrate(M4_USART_TypeDef *USARTx, uint32_t u32Baudrate,
华大HC32F460 USART DMA超时接收 爬坑
shengxial的博客
10-25 1582
USART DMA通过TIME0超时接收数据帧这个功能虽然在数据手册上提过，但是官方demo不给，网上的代码要么不全要么驱动版本不一致，于是有这个坑 1. 基本框图 涉及到的模块：USART，AOS, DMA 其中，AOS模块不需要CPU的参与即可触发，触发源记为event，触发接口记为socket，socket会关联相关动作。 大坑注意： 1）图中的实线是数据手册明确说明的event和socket，需要配置，相关代码： /* Enable ...
华大HC32F460RS485通信实验
ZhuoWuKeJi的博客
12-30 1053
华大HC32F460RS485通信实验
EV_HC32F460_UART调试
嵌入式Stark
07-17 1630
3.EV_HC32F460_UART调试 简介 USART：通用同步和异步收发器 UART：通用异步收发器 当进行异步通信时,这两者是没有区别的。区别在于USART比UART多了同步通信功能。 这个同步通信功能可以把USART当做SPI来用，比如用USART来驱动SPI设备。 同步是指：发送方发出数据后，等接收方发回响应以后才发下一个数据包的通讯方式。 异步是指：发送方发出数据后，不等接收方发回响应，接着发送下个数据包的通讯方式。 同步是阻塞模式，异步是...
HC32_HC32F072FAUA_基于中断的固定长度UART通信
heqiunong的专栏
07-25 589
复制一个新工程，重命名为UART,开启美妙的UART通信之旅。
hc32f460串口dma
07-01
### 回答1： hc32f460是一款高性能的32位微控制器，它支持串口DMA功能。串口DMA是一种通过直接内存访问（DMA）方式来传输数据的技术，可以大大提高串口通信的效率。 hc32f460的串口DMA功能通过将串口数据的传输交给DMA控制器来完成，减轻了CPU的负担。在使用串口DMA时，首先需要配置DMA控制器，包括设置DMA通道、传输数据的起始地址和长度等。然后，将数据写入串口发送缓冲区，并启动DMA传输。DMA控制器会自动根据配置的参数从内存中读取数据，并将数据直接发送到串口，无需CPU的干预。 串口DMA可以极大地提高数据传输的速度，尤其适用于大量数据的传输和高速通信的场景。相比于传统的CPU中断方式，串口DMA能够实现数据的无缝传输，提高了系统的响应速度和实时性。 hc32f460的串口DMA功能还具有灵活的配置选项，例如可以选择不同的DMA通道进行数据传输，还支持循环传输模式和多缓冲区传输，以满足不同的应用需求。 总之，hc32f460的串口DMA功能是一项强大且高效的数据传输技术，能够提升系统的性能和可靠性。通过 DMA 控制器和串口的协同工作，能够实现高速、实时的数据传输，广泛应用于各种通信和控制系统中。 ### 回答2： HC32F460是一款基于ARM Cortex-M4内核的高性能微控制器。它具有丰富的外设功能，包括多个串口接口和DMA控制器。串口DMA是指通过DMA控制器来管理串口数据的传输。 在HC32F460中，串口DMA的工作原理如下：首先，我们需要配置串口控制器的相关参数，包括波特率、数据位、停止位和校验位等。然后，我们通过编程的方式配置DMA控制器，以使其能够将串口数据的发送和接收与内存之间进行直接传输。 对于串口发送功能，当我们要发送一段数据时，首先将数据存储在内存中的发送缓冲区中，然后通过编程的方式触发DMA控制器开始传输。DMA控制器会自动从内存中读取数据，并通过串口控制器发送出去。在传输过程中，我们无需干预，可以继续进行其他的操作。 对于串口接收功能，当有数据到达时，串口控制器会将数据存储在接收缓冲区中。然后，我们再次通过编程的方式触发DMA控制器开始传输。DMA控制器会自动将数据从接收缓冲区读取到内存中，以供后续的处理使用。同样，在传输过程中我们无需干预。 通过使用串口DMA，我们可以实现高效的串口数据传输，提高系统的性能。它可以减少CPU的负载，降低数据传输的延迟。同时，由于采用了直接内存访问的方式，可以减少CPU与外设之间的数据拷贝，提高数据传输的速度。 总之，HC32F460串口DMA是一种高效的数据传输方式，通过使用DMA控制器来管理串口数据的传输，可以提高系统的性能和可靠性。 ### 回答3： HC32F460是一种高性能的32位MCU芯片，具有丰富的外设接口和强大的处理能力。其中，串口DMA是这款芯片上的一个功能模块，用于实现串口的数据传输。 串口DMA可以通过配置寄存器来进行初始化设置。首先需要配置串口的传输参数，例如波特率、数据位数、停止位等。然后设置DMA的初始化参数，包括数据的传输方向、传输大小、源地址和目的地址等。接下来，通过使能串口DMA功能，就可以开始进行数据传输。 串口DMA的工作原理是通过中断触发和DMA通道来实现数据的传输。当有数据到达串口时，串口DMA会产生一个中断请求，触发DMA通道进行数据的传输。DMA通道会自动从源地址读取数据，并将数据传输到目的地址。数据传输完成后，DMA通道会产生一个传输完成的中断，在此中断中可以进行相应的处理，例如发送一个完成信号给外部设备。 串口DMA的优点是能够大大提高数据传输的效率和可靠性。由于数据传输由DMA通道完成，可以减轻CPU的负担，提高系统的响应速度。同时，采用DMA传输数据，可以避免由于CPU繁忙而导致的数据丢失或错误。因此，串口DMA在需要高效、稳定传输大量数据的应用中非常有用。 总之，HC32F460的串口DMA是一种可靠高效的数据传输方式，通过合理配置和使用，可以实现高速稳定的串口通信。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值