HC32F460 串口 DMA 发送 接收

最新推荐文章于 2025-04-07 14:46:37 发布
最新推荐文章于 2025-04-07 14:46:37 发布
阅读量6.2k 收藏 54
点赞数 18
分类专栏： HC32 文章标签： 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_34327726/article/details/117387724
版权
本文详细介绍了如何在STM32上使用DMA进行串口通信，包括串口发送和接收的DMA配置、中断设置、超时定时器的使用。通过示例代码展示了初始化过程，如串口、DMA通道、定时器的配置，并阐述了发送和接收中断处理流程。此外，还讨论了接收超时定时器通道的选择和限制。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

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;
}
网络传输大端序_大端、小端与网络字节序
weixin_39638048的博客
01-17 1713
大端(Big-Endian)，小端(Little-Endian)以及网络字节序的概念在编程中经常会遇到，网络字节序(Network Byte Order)一般是指大端(Big-Endian，对大部分网络传输协议而言)传输，大端小端的概念是面向多字节数据类型的存储方式定义的，小端就是低位在前(低位字节存在内存低地址，字节高低顺序和内存高低地址顺序相同)，大端就是高位在前，(其中“前”是指靠近内存低地...
计算机网络 | 网络字节序 / 字节序类型验证 / 字节序转换
u013669912的博客
06-24 1753
……
网络字节序
baiseda
09-19 292
网络字节序 一.字节序 字节序是由于不同的主处理器和操作系统，对大于一个字节的变量在内存中的存放顺序不同而产生的。 字节序通常有大端字节序列和小端字节序两种分类方法。 由于主机的千差万别，主机的字节序不能做到统一，但是网络上传输的数值，它们有统一的规定。网络字节序：是指多字节变量在网络传输时的表示方法，网络字节序采用高端字节序的表示方法。 二.大端字节序和小端字节序 字节序...
【C语言】大小端字节序和字节序判断
最新发布
2501_90303633的博客
04-07 1507
在上章介绍了整形在内存的储存，了解了原码，反码，补码，知道了整数在内存的储存一般是补码，解决了负数相加的问题。那么在本章为大家讲解一下大小端字节序。
大端模式与小端模式、网络字节顺序与主机字节顺序
wuqingCL的博客
05-05 273
大端模式与小端模式 　　一、概念及详解 　　在各种体系的计算机中通常采用的字节存储机制主要有两种： big-endian和little-endian，即大端模式和小端模式。 　　先回顾两个关键词，MSB和LSB： 　　MSB:Most Significant Bit ------- 最高有效位 LSB:Least Significant Bit -------...
网络字节序和主机字节序
Rabo_cheng的专栏
08-30 3306
  不同的CPU有不同的字节序类型 这些字节序是指整数在内存中保存的顺序 这个叫做主机序 最常见的有两种1． Little endian：将低序字节存储在起始地址2． Big endian：将高序字节存储在起始地址LE little-endian 最符合人的思维的字节序 地址低位存储值的低位 地址高位存储值的高位 怎么讲是最符合人的思维的字节序，是因为从人的第一观感来说 低位值小，就应该放在内
大小端介绍与分析
胡图图
09-04 674
1. 字节序 字节序即字节的存储顺序，如果数据都是单字节的，那怎么存储无所谓了，但是对于多字节数据，比如int，double等，就要考虑存储的顺序了。字节序是硬件层面的东西，通常只和你使用的处理器架构有关，而和编程语言无关。字节序分为大端序和小端序。 大端序：数据的高位字节存放在地址的低端 低位字节存放在地址高端。 小端序：数据的高位字节存放在地址的高端 低位字节存放在地址低端。 0x1234567的大端字节序和小端字节序的写法如下图。 可见，大端模式和字符串的存储模式类似...
网络字节序和主机字节序（大端/小端）
Jackie_Ryan的专栏
03-26 9120
（一）背景介绍 不同的CPU具有不同的字节序类型，这些字节序是指整数在内存中的保存顺序。最常见的有有两种： （1）little endian：小端，将低位字节保存在低位地址。 （2）big endian：大端，将高位字节保存在低位地址。 例子：如果我们将0x1234abcd写入到以0x0000开始的内存中，则结果为： big-endianlittle-endian 0x0...
基于大端法、小端法以及网络字节序的深入理解
09-05
1. 大端法（Big-Endian）：在大端字节序中，最高位字节（MSB，Most Significant Byte）存储在最低的内存地址，而最低位字节（LSB，Least Significant Byte）存储在最高的地址。例如，一个32位整数0x12345678在大端法...
浅学字节序——字节序大小端，主机字节序，网络字节序的理解
07-08
例如，x86架构主要采用小端字节序，而很多网络协议标准（如TCP/IP）则规定使用大端字节序，以确保跨平台兼容性。 ### 主机字节序与网络字节序 #### 主机字节序 主机字节序指的是本地计算机系统的字节序。根据所...
字节存储顺序: little-endian小端,big-endian大端 教程
12-16
你是否遇到过,内存中的数据顺序颠倒 你存入1234,实际存储的是3412. 字节存储顺序: little-endian小端,big-endian大端 教程 主机序,网络序 hton,ntoh
网络字节序列-大端序和小端序
xiexiaojing的博客
12-04 4734
引子从《一个http请求进来都经过了什么(2021版)》到《懂得三境界-使用dubbo时请求超过问题》，再到《接下来一段时间会对大家进行网络通信的魔鬼训练-理解socket》和《深入理解M...
关于python格式对齐的问题_Python及字节对齐的问题
weixin_39633891的博客
11-24 453
该结构大致如下：struct TestStruct{int data1;char data2;char data3;};对应的Python代码：import structs = struct.unpack("icc", buf) #buf是从网络接收的字节流结果却报“Unpack str size does not match format”错。很明显是C++ struct产生的size和Pyth...
大小端及网络字节序
热门推荐
编程随笔与杂谈
01-22 3万+
什么是大端模式、小端模式 　　“大端”和”小端”表示多字节值的哪一端存储在该值的起始地址处;小端存储在起始地址处,即是小端字节序;大端存储在起始地址处,即是大端字节序;具体的说： 　　 ①大端字节序（Big Endian）：最高有效位存于最低内存地址处，最低有效位存于最高内存处； 　　 ②小端字节序（Little Endian）：最高有效位存于最高内存地址，最低有效位存于最低内存处。
大端、小端、字节序
noevil的博客
03-12 3449
字节序就是数据在计算机内存或者网络中的字节存储顺序。大多数计算机（x86架构）都采用小端字节序（little-endian），即将低位字节存储在内存的低地址处，高位字节存储在内存的高地址处。而网络通信使用的则是大端字节序（big-endian），即将高位字节存储在内存的低地址处，低位字节存储在内存的高地址处。
大端字节序和小端字节序
weixin_53361650的博客
08-18 4721
大端字节序和小端字节序1.什么是大小端字节序2.验证大小端字节序 1.什么是大小端字节序 计算机硬件有两种储存数据的方式：大端字节序（MSB）和 小端字节序（LSB）。 小端字节序（LSB） 将这样的数据存储在计算机中，地址从地位到高位应该是：78 56 34 12 int a=0x12345678 一共四个字节的地址，假设从0x1001 ~ 0x1004；那么，对于小端字节序来说系统是这样存储的： 由图可以看出，小端字节序的存储规则是：数据的低位存储在地址低位，数据的高位存储在地址高位 大端字节序（
字节序 Little-Endian和Big-Endian
发展是曲折的但也是前进的
07-22 1680
网络字节顺序[1]  字节序，顾名思义字节的顺序，再多说两句就是大于一个字节类型的数据在内存中的存放顺序(一个字节的数据当然就无需谈顺序的问题了)。其实大部分人在实际的开发中都很少会直接和字节序打交道。唯有在跨平台以及网络程序中字节序才是一个应该被考虑的问题。 在所有的介绍字节序的文章中都会提到字节序分为两类：Big-Endian和Little-Endian，引用标准的Big-Endian和L
网络字节序是大端吗
04-04
### 网络字节序与大端模式的关系 在网络通信中，数据通常以字节流的形式进行传输。为了确保不同设备之间能够正确解析接收到的数据，TCP/IP 协议规定了一种统一的字节序标准——即 **网络字节序**。网络字节序实际上是一种特定的大端（Big-Endian）模式[^3]。 #### 大端模式的特点 在大端模式下，多字节数值中的最高有效字节（Most Significant Byte, MSB）被放置在较低的内存地址或优先传输的位置。这意味着，在网络传输过程中，数值的第一个字节总是其高位字节[^2]。 #### 小端模式对比 相比之下，小端（Little-Endian）模式则将最低有效字节（Least Significant Byte, LSB）放在较低的内存地址或优先传输位置。这种模式常见于某些本地计算机架构中，但在网络传输中并不适用。 #### 网络字节序的具体实现 根据 TCP/IP 协议的规定，网络字节序遵循大端模式。因此，在实际应用中，发送方会将数据转换为大端格式后再进行传输；而接收方在解析这些数据之前，则可能需要将其从大端格式转换回适合本机使用的字节序（可能是小端）。常见的函数如 `htonl()` 和 `ntohl()` 可用于完成主机字节序到网络字节序之间的相互转换[^1]。 以下是两个简单的 C 语言代码示例： ```c // 主机字节序转网络字节序 (假设为主机为 Little-Endian) uint32_t host_to_network(uint32_t value) { return htonl(value); } // 网络字节序转主机字节序 (假设为主机为 Little-Endian) uint32_t network_to_host(uint32_t value) { return ntohl(value); } ``` 通过上述方法可以保证无论两端机器使用何种内部字节序，都能正常交换并理解彼此的数据。 综上所述，网络字节序确实采用了大端模式来定义数据在网络上的排列次序。 ---
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值