STM32自定义串口通信协议

已于 2024-01-08 16:08:04 修改
阅读量1.3k 收藏 29
点赞数 16
分类专栏： 通信协议 文章标签： stm32 嵌入式硬件 单片机
于 2023-12-20 14:38:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/binhao002/article/details/135093369
版权

目录

前沿

1 命令格式

2 应用举例

2.1 读寄存器

2.2 写寄存器  

3 编写代码

3.1 main函数代码

3.2 中断函数代码

3.3 串口函数代码

3.4 事件处理函数代码

3.5 串口发送代码

4 代码演示

4.1 读寄存器

4.2 写寄存器

前沿

        这段时间在写一个自动化测试平台的下位机软件，借此机会给大家分享一下自定义的串口通信协议。

1 命令格式

帧格式：[数据头码] [类型码] [长度码] [ID 码] [参数码1] [参数码2]... [参数码n] [校验码] [数据尾码] 注意：参数码最少为1

  • 数据头码：‘$’ '#' [0x24 0x23]（主到从） ，‘@’ '#' [0x40 0x23]（从到主）

  • 类型码：用于定于具体操作的类型，可以是读写寄存器、控制电机，也可以是控制摄像头等

  • 数据尾码：'#' '@'[0x23 0x40]（主到从），‘#’ ‘$’[0x23 0x24]（从到主）长度码：1byte[类型码] +1byte [ID 码] + nbyte[参数码] （参数码最少为1）+1byte[校验码]

  • ID码：ID码根据类型码的不同含义有所不同

  • 参数码：参数码可表示地址、数据、子类型等

  • 校验码：等于和校验^0xFF，计算公式： [类型码] + [长度码] + [ID 码] + [参数码1] + [参数码2] +... + [参数码n]（参数码最少为1）

2 应用举例

      这里举一个寄存器的读写操作命令格式。寄存器数据位为8位。

类型码：0x01

ID码：读（0x00），写（0x01）

2.1 读寄存器

通信方向数据头码长度码类型码ID码参数码1参数码2参数码3参数码n校验码数据尾码
主-->从"$#"0x050x010x00addrlen无无xx"#@"
从-->主"@#"xx0x010x00lendatadatadataxx"#$"

addr：读寄存器的地址

  • 0x00：寄存器1地址

  • 0x01：寄存器2地址

  • 0x02：寄存器3地址

len：读取的长度

data：读取的数据，地址依次递增

举例：

主-->从：0x24 0x23 0x05 0x01 0x00 0x01 0x02 0xxx 0x23 0x40

表示从0x01地址开始，读取2个连续的地址的值

从-->主：0x40 0x23 0x06 0x01 0x00 0x02 0xxx 0xxx 0xxx 0x23 0x24

返回0x01和0x02地址的值

2.2 写寄存器  

通信方向数据头码长度码类型码ID码参数码1参数码2参数码3参数码n校验码数据尾码
主-->从"$#"xx0x010x01addrlendatadataxx"#@"
从-->主"@#"xx0x010x01addrlendatadataxx"#$"

addr：写寄存器的地址

  • 0x00：寄存器1地址

  • 0x01：寄存器2地址

  • 0x02：寄存器3地址

len：写的长度，字节为单位

data：写的数据，地址依次递增

举例：

主-->从：0x24 0x23 0x07 0x01 0x01 0x01 0x02 0x01 0x02 0xxx 0x23 0x40

表示向0x01地址写入0x01值，0x02地址写入0x02值

从-->主：0x24 0x23 0x07 0x01 0x01 0x01 0x02 0x01 0x02 0xxx 0x23 0x40

返回状态

3 编写代码

3.1 main函数代码

        main函数主要实现协议的解析，根据不同的类型码进行具体的操作。cmdSet是一个函数指针数组，里面存放不同类型的操作函数。

typedef void (*p_cmdType)(CommDataWithHost_Typedef *commdata_struct);

/* 不同类型码执行不同的函数 */
p_cmdType cmdSet[MAX_CMD_SUPPORT]=
{
    Function1,             /* 其他功能函数 */
    RW_RegFunction         /* 读写寄存器函数 */
    
};

/* 参数码的大小 */
#define PARA_CODE_LEN 32

/* 帧结构 */
typedef struct
{
    __IO uint8_t framehead1;
    __IO uint8_t framehead2;
    __IO uint8_t length;
    __IO uint8_t type;
    __IO uint8_t id;
    __IO uint8_t function[PARA_CODE_LEN];
    __IO uint8_t check;
    __IO uint8_t frameend1;
    __IO uint8_t frameend2;
}CommDataWithHost_Typedef;

CommDataWithHost_Typedef RxDataWithHost_Structure;
__IO uint8_t ReceiveData_InformFlag = RXDATA_FROMHOST_FRAMEHEAD1_FLAG;
extern p_cmdType cmdSet[MAX_CMD_SUPPORT];

/*******************************************************************************
* Function Name  : main.
* Description    : Main routine.
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
int main(void)
{
    void (*pfun)(CommDataWithHost_Typedef *);
    
    USART_Config();

    /* Infinite loop */
    while (1)
    {
        if(ReceiveData_InformFlag == RXDATA_FROMHOST_COMPLETED_FLAG)
        {
            ReceiveData_InformFlag = RXDATA_FROMHOST_FRAMEHEAD1_FLAG;
            
            /* 防止数组越界 */
            if (RxDataWithHost_Structure.type < MAX_CMD_SUPPORT)
            {
                //p_cmdType pfun = cmdSet[RxDataWithHost_Structure.type];
                pfun = cmdSet[RxDataWithHost_Structure.type];
                
                if (pfun != 0)
                {
                    pfun(&RxDataWithHost_Structure);
                }                 
            }
          
        }  
    }
}

3.2 中断函数代码

        中断函数主要是接收串口收到的数据，并进行逐一处理。因为串口是一个字节一个字节的接收数据，所以在每次串口接收到数据之后，都会置位下一次将要接收的标志。

        这里也对数据的越界做了相应的处理，处理代码：

if ((tempData > 3) && (tempData <= (PARA_CODE_LEN + 3)))

extern CommDataWithHost_Typedef RxDataWithHost_Structure;
extern __IO uint8_t ReceiveData_InformFlag;

/* Definition for information flag of receive data from pc host  */
typedef enum
{
    RXDATA_FROMHOST_FRAMEHEAD1_FLAG = 0,
    RXDATA_FROMHOST_FRAMEHEAD2_FLAG,
    RXDATA_FROMHOST_LENGTH_FLAG,   
    RXDATA_FROMHOST_TYPE_FLAG,      
    RXDATA_FROMHOST_ID_FLAG,        
    RXDATA_FROMHOST_FUNCTION_FLAG,  
    RXDATA_FROMHOST_CHECKDATA_FLAG, 
    RXDATA_FROMHOST_FRAMEEND1_FLAG, 
    RXDATA_FROMHOST_FRAMEEND2_FLAG, 
    RXDATA_FROMHOST_COMPLETED_FLAG 
    
}RXDATA_FROMHOST_ENUM;

/* RX帧头帧尾 */
#define RXDATA_WITHHOST_FRAMEHEAD1        '$'
#define RXDATA_WITHHOST_FRAMEHEAD2        '#'
#define RXDATA_WITHHOST_FRAMEEND1         '#'
#define RXDATA_WITHHOST_FRAMEEND2         '@'

/* TX帧头帧尾 */
#define TXDATA_WITHHOST_FRAMEHEAD1        '@'
#define TXDATA_WITHHOST_FRAMEHEAD2        '#'
#define TXDATA_WITHHOST_FRAMEEND1         '#'
#define TXDATA_WITHHOST_FRAMEEND2         '$'

/**
  * @brief  This function handles USART1 interrupt request.
  * @param  None
  * @retval None
  */
void DEBUG_USART_IRQHandler(void)
{
    uint8_t tempData = 0x00;
    static uint8_t tempcnt = 0;

    if (USART_GetITStatus(DEBUG_USARTx, USART_IT_RXNE) != RESET)
    {
        tempData = USART_ReceiveData(DEBUG_USARTx);

        switch (ReceiveData_InformFlag)
        {
            /* Received 1 byte : frame head data 1 = '$' */
            case RXDATA_FROMHOST_FRAMEHEAD1_FLAG:
                if (tempData == RXDATA_WITHHOST_FRAMEHEAD1)
                {
                    RxDataWithHost_Structure.framehead1 = tempData;
                    ReceiveData_InformFlag = RXDATA_FROMHOST_FRAMEHEAD2_FLAG;
                }
                else
                {
                    ReceiveData_InformFlag = RXDATA_FROMHOST_FRAMEHEAD1_FLAG;
                }

                break;

            /* Received a frame head data 2 : '#' */
            case RXDATA_FROMHOST_FRAMEHEAD2_FLAG:
                if (tempData == RXDATA_WITHHOST_FRAMEHEAD2)
                {
                    RxDataWithHost_Structure.framehead2 = tempData;
                    ReceiveData_InformFlag = RXDATA_FROMHOST_LENGTH_FLAG;
                }
                else
                {
                    ReceiveData_InformFlag = RXDATA_FROMHOST_FRAMEHEAD1_FLAG;
                }

                break;

            /* Received data length */
            case RXDATA_FROMHOST_LENGTH_FLAG:

                /* 判断长度段的数据是否满足要求，至少为4,不能大于PARA_CODE_LEN+3 */
                if ((tempData > 3) && (tempData <= (PARA_CODE_LEN + 3)))
                {
                    RxDataWithHost_Structure.length = tempData;
                    ReceiveData_InformFlag = RXDATA_FROMHOST_TYPE_FLAG;
                    tempcnt = 0;
                }
                else
                {
                    ReceiveData_InformFlag = RXDATA_FROMHOST_FRAMEHEAD1_FLAG;
                }

                break;

            /* Received data type information */
            case RXDATA_FROMHOST_TYPE_FLAG:
                RxDataWithHost_Structure.type = tempData;
                ReceiveData_InformFlag = RXDATA_FROMHOST_ID_FLAG;
                break;

            /* Received id information */
            case RXDATA_FROMHOST_ID_FLAG:
                RxDataWithHost_Structure.id = tempData;
                ReceiveData_InformFlag = RXDATA_FROMHOST_FUNCTION_FLAG;
                break;

            /* Received function information */
            case RXDATA_FROMHOST_FUNCTION_FLAG:
                RxDataWithHost_Structure.function[tempcnt] = tempData;
                tempcnt++;

                if ((RxDataWithHost_Structure.length - 3) == tempcnt)
                {
                    ReceiveData_InformFlag = RXDATA_FROMHOST_CHECKDATA_FLAG;
                }

                break;

            /* Received check information */
            case RXDATA_FROMHOST_CHECKDATA_FLAG:
                RxDataWithHost_Structure.check = tempData;
                ReceiveData_InformFlag = RXDATA_FROMHOST_FRAMEEND1_FLAG;
                break;

            /* Received frame end data 1 = '#' */
            case RXDATA_FROMHOST_FRAMEEND1_FLAG:
                if (tempData == RXDATA_WITHHOST_FRAMEEND1)
                {
                    RxDataWithHost_Structure.frameend1 = tempData;
                    ReceiveData_InformFlag = RXDATA_FROMHOST_FRAMEEND2_FLAG;
                }
                else
                {
                    ReceiveData_InformFlag = RXDATA_FROMHOST_FRAMEHEAD1_FLAG;
                }

                break;

            /* Received frame end data 2 = '@' */
            case RXDATA_FROMHOST_FRAMEEND2_FLAG:
                if (tempData == RXDATA_WITHHOST_FRAMEEND2)
                {
                    RxDataWithHost_Structure.frameend2 = tempData;
                    ReceiveData_InformFlag = RXDATA_FROMHOST_COMPLETED_FLAG;
                }
                else
                {
                    ReceiveData_InformFlag = RXDATA_FROMHOST_FRAMEHEAD1_FLAG;
                }

                break;

            default:
                ReceiveData_InformFlag = RXDATA_FROMHOST_FRAMEHEAD1_FLAG;
                break;
        }
    }
}

3.3 串口函数代码

        串口初始化代码主要初始化串口的波特率、奇偶校验、停止位等信息。并使能接收中断。

/**
  * @brief  Configure NVIC.
  * @param  None
  * @retval None
  */
static void NVIC_Configuration(void)
{
    NVIC_InitTypeDef NVIC_InitStructure;

    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    NVIC_InitStructure.NVIC_IRQChannel = DEBUG_USART_IRQ;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
}

/**
  * @brief  Initializes and config USART.
  * @param  None
  * @retval None
  */
void USART_Config(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;

    /* Enable USART and GPIO clock */
    DEBUG_USART_TX_GPIO_AHBClkCmd(DEBUG_USART_TX_GPIO_CLK, ENABLE);
    DEBUG_USART_RX_GPIO_AHBClkCmd(DEBUG_USART_RX_GPIO_CLK, ENABLE);
    DEBUG_USART_APBxClkCmd(DEBUG_USART_CLK, ENABLE);

    /* Configure the GPIO of USART_TX to AF-PP mode */
    GPIO_InitStructure.GPIO_Pin = DEBUG_USART_TX_GPIO_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(DEBUG_USART_TX_GPIO_PORT, &GPIO_InitStructure);

    /* Configure the GPIO of USART_RX to floating input mode */
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    GPIO_InitStructure.GPIO_Pin = DEBUG_USART_RX_GPIO_PIN;
    GPIO_Init(DEBUG_USART_RX_GPIO_PORT, &GPIO_InitStructure);

    /* Configure the working parameters of the USART  */
    USART_InitStructure.USART_BaudRate = DEBUG_USART_BAUDRATE;
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    USART_InitStructure.USART_StopBits = USART_StopBits_1;
    USART_InitStructure.USART_Parity = USART_Parity_No ;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    USART_Init(DEBUG_USARTx, &USART_InitStructure);

    NVIC_Configuration();

    USART_ITConfig(DEBUG_USARTx, USART_IT_RXNE, ENABLE);

    USART_Cmd(DEBUG_USARTx, ENABLE);
}

3.4 事件处理函数代码

        处理读写事件，读主要是读出寄存器的内容返回给主机，写主要是把主机下发的内容写入到从机的寄存器中，读写这两个函数需要自己实现。

/**
  * @brief  读写寄存器
  * @param  RxData: 接收的串口数据.
  * @retval None
  */
void RW_RegFunction(CommDataWithHost_Typedef *RxData)
{
    CommDataWithHost_Typedef TxData;
    uint8_t i = 0;

#ifdef DATA_CHECK  
    uint8_t tempCheckValue = 0;
       
    tempCheckValue = CalcuCheckValue_DataWithHost(RxData);
        
    if (tempCheckValue == RxData->check)
#endif
    {
        /* 读 */
        if (RxData->id == 0x00)
        {
            TxData.length = RxData->length+RxData->function[1]-1;  //总长度
            TxData.type = RxData->type;
            TxData.id = RxData->id;
            TxData.function[0] = RxData->function[1];             //数据长度

            /* 依次读出寄存器的值 */
    //        pEEPROMReg->Read((uint8_t*)&TxData.function[1+i], RxData->function[0], RxData->function[1]);
            
            TransmitData_CommunicateWithHost(&TxData); 
        }
        /* 写 */
        else if (RxData->id == 0x01)
        {
    //        pEEPROMReg->Write((uint8_t*)&RxData->function[2], RxData->function[0], RxData->function[1]);
            TxData.length = RxData->length;  //总长度
            TxData.type = RxData->type;
            TxData.id = RxData->id;
            /* 依次读出寄存器的值，并反馈给TxData */
            for (i=0; i<(RxData->length-3); i++)
            {
                TxData.function[i] = RxData->function[i];
            }
            
            TransmitData_CommunicateWithHost(&TxData);         
        }          
    }
}

3.5 串口发送代码

        串口发送代码分为校验发送和不带校验发送，校验通过CalcuCheckValue_DataWithHost函数实现。串口发送通过TransmitData_CommunicateWithHost实现。

        校验与否可通过宏定义决定，因为串口助手进行验证的时候，校验码不好计算，所以在测试阶段不校验，在交付阶段需要把校验打开。

/**
  * @brief  Calculate the data check value of communication with pc host.
  * @param  TxData: Communication data structure.
  * @retval None
  */
uint8_t CalcuCheckValue_DataWithHost(CommDataWithHost_Typedef* TxData)
{
    uint8_t i;
    uint8_t tempValue = 0x00;
  
    for(i=0; i<(TxData->length-3); i++)
    {
        tempValue = (uint8_t)(tempValue + TxData->function[i]);
    }
    tempValue = (uint8_t)(tempValue                 + \
                          TxData->length   + \
                          TxData->type     + \
                          TxData->id );
    tempValue = tempValue ^ 0xFF;
    
    return tempValue;
}

/**
  * @brief  Communicate and transmit data with pc host.
  * @param  TxData: Communication data structure.
  * @retval None
  */
void TransmitData_CommunicateWithHost(CommDataWithHost_Typedef* TxData)
{
    uint8_t i = 0;
    uint8_t tempCheckValue = 0;

    /* 防止数组越界 */
    if ((TxData->length-3) <= PARA_CODE_LEN)
    {
        TxData->framehead1 = TXDATA_WITHHOST_FRAMEHEAD1;
        TxData->framehead2 = TXDATA_WITHHOST_FRAMEHEAD2;
        TxData->frameend1 = TXDATA_WITHHOST_FRAMEEND1;
        TxData->frameend2 = TXDATA_WITHHOST_FRAMEEND2;
      
        tempCheckValue = CalcuCheckValue_DataWithHost(TxData);
        
        usartWithHost_SendByte(TxData->framehead1);
        usartWithHost_SendByte(TxData->framehead2);
        usartWithHost_SendByte(TxData->length);
        usartWithHost_SendByte(TxData->type);
        usartWithHost_SendByte(TxData->id);
      
        for(i=0; i<(TxData->length-3); i++)
        {
            usartWithHost_SendByte(TxData->function[i]);
        }
        
        usartWithHost_SendByte(tempCheckValue);
        usartWithHost_SendByte(TxData->frameend1);
        usartWithHost_SendByte(TxData->frameend2);                   
    }
}

4 代码演示

4.1 读寄存器

4.2 写寄存器

binhaoPro
关注
  • 16
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
STM32的串口协议
qq_45917157的博客
10-24 2885
一、串口协议 1.串口协议 串口通信指串口按位（bit）发送和接收字节。尽管比特字节（byte）的串行通信慢，但是串口可以在使用一根线发送数据的同时用另一根线接收数据。串口通信协议是指规定了数据包的内容，内容包含了起始位、主体数据、校验位及停止位，双方需要约定一致的数据包格式才能正常收发数据的有关规范。在串口通信中，常用的协议包括RS-232、RS-422和RS-485。 2.RS-232标准 （1）介绍 RS-232是美国电子工业联盟制定的串行数据通信接口标准，原始编号全称是EIA-RS-232（简称RS
通过自定义串口通信协议实现STM32采集的图像发送到上位机查看
11-05
串口发送图像 通过自定义串口通信协议实现STM32采集的图像发送到上位机查看 开发平台: VS2019, Keil 5 开发技术: C#, WinForm, C++ 使用到的技术: STM32, SerialPort, Winform 需要提前指定要发送的图像大小, 否则会出现解析失败的情况 右侧显示的图像可以实现自由的缩放, 通过鼠标滚轮可以轻易的实现缩放操作
STM32 - 用户自定义通讯协议
如图所示
07-27 2791
接收数据不固定的情况下
STM32串口自定义协议设计与实现
最新发布
TLY983074808的博客
04-02 433
在嵌入式系统开发中，串口通信是一种常见的数据传输方式。为了保证数据的可靠传输，有时需要设计一种自定义的串口协议。本文将介绍如何利用ST32微控制器实现串口自定义协议，以确保数据的完整性和可靠性。自定义串口协议通常由起始字节、数据内容、校验和和结束字节组成。起始字节用于标识数据包的开始，结束字节表示数据包的结束。校验和用于验证数据的完整性，可以通过累加数据内容得到，接收端根据校验和检测数据是否损坏。
STM32标准库开发——USART串口协议
纵行山河万里~
01-18 353
校验位一般采用奇偶校验，如果使用校验那么一帧长度一共11位。在奇偶校验中，一个附加的校验位被添加到数据中。这个校验位的值由数据中的比特位确定。奇校验要求校验位使整个数据的奇数个1，而偶校验要求校验位使整个数据的偶数个1。Level）是指用两个相对的电平来表示信号的电压差异。它是通过将信号相对于某个参考电平进行比较来确定的。例如电压差在某个范围表示1，在某个范围表示0。波特率是指一秒传输的位数，例如9600bps，意味着1s内要传输9600bit。差分电平（Differential Voltage。
STM32之如何定义串口通讯协议定义ASCII和hex
sudaroot的博客
01-15 7252
在我们定义串口通讯协议的时候，肯定是首先要考虑通讯协议内容是以ASCII码 还是 hex十六进制。 对于这两类的各有各的优点和缺点。 一、ASCII 优点： 1、简单直观。（比如在串口调试助手很容易看懂协议上传的数据） 2、数据起始标志位和结束标志位唯一，不与数据内容冲突。（比如起始位为SS，结束位为\r\n） 3、适用大小端MCU的协议通讯，8位单片机基本都是大端，32位及以...
浅谈STM32串口通信(二)自定义帧格式和超时接收
小胡的博客
04-26 7482
123
STM32自定义串口通信协议.zip
03-09
本资源内代码实现功能为自定义串口通信协议的收发，还包括串口助手，蓝牙连接，测试指令，博客word版本等文档。
STM32 自定义串口协议
热门推荐
尽欢的博客
03-08 1万+
STM32 自定义串口协议串行通信原理与优缺点分类按通信方向按通信方式异步串行引脚连接串口外设之间ARM与PC之间字符帧格式串口通信过程串口框图并行通信异步串行实例（自定义通信协议）项目需求项目框架上位机下传帧格式代码设计 串行通信 在设计实现某种功能的系统时，常需要不同设备之间的通信。通信主要有串行和并行两种方式，应用比较广泛的UART(Universial Asynchonous Receiver Transmitter)通用异步收发器,SPI(Serial Peripheral Interface)串
自定义串口协议
weixin_46185705的博客
04-04 1844
文章目录前言一、有限状态机有限状态机代码接收数据缓冲缓冲要求循环队列一、循环队列代码实现循环队列头文件：源文件：二、有限状态机与解码有限状态机核心实现代码有限状态机与解码头文件源文件三、使用小例子总结 前言 此篇将结合有限状态机与循环队列，构建一个稳定可靠的自定义串口协议，如果代码有点难懂，可以直接移植使用，看使用demo就好啦，我都封装好了。 简单提一下实现的主要功能： 一·：命令模式，根据输入字符与缓冲区的内容进行比对，返回真假值。 二·：调参模式，根据输入字符与缓冲区的内容进行比对，返回传入数字的值
STM32串口实验+自定义协议接收16进制数据+发送1个（2个）字符+发送字符串函数.zip
01-03
STM32串口使用自定义协议接收一串十六进制数据并进行储存 提取十六进制数据的两个字节转化为十进制数据 发送一个字节函数 发送两个字节函数 发送字符串函数 重定向printf函数 重定向scanf函数
stm32F控制柜程序，带串口协议
09-22
stm32串口中断通信，串口协议定义及实现，定时器在串口通信中的使用。
stm32串口通信协议简单教程
12-20
stm32串口通信协议简单教程，stm32串口通信协议简单教程
usart.rar_STM32 串口通信_stm32 串口协议_uart_自定义协议
09-21
本程序是基于stm32自定义串口通信协议
自定义帧--不同模块间使用串口进行数据交互
A3366_225的博客
04-01 1211
笔者的实验平台为STM32和AIR724UG，这两款芯片一种是常用的使用C语言开发的单片机一种是基于luat os的lua开发方式的通讯模块。算是可以比较本文所论述的使用自定义帧通过串口在不同平台进行数据交互的形式，算是抛砖引玉。 STM32与AIR724UG 概述 对于AIR724UG而言一般使用串口进行通讯，以下将介绍两种通讯协议的制订与实现方式，包含关于通讯协议通用性与帧长度之间的取舍。其中STM32使用C语言库函数编写、AIR724UG使用Lua脚本编写。 一般一个数据帧包含帧头、帧长度（包个数）、
自定义的串口通信协议
qq_22842309的博客
01-17 4761
自定义一主多从通讯协议
STM32串口自定义数据接收协议
祥玉汪的博客
09-10 6579
最近使用STM32做串口数据收发，遇到了一些问题。折腾了一番，在此记录一下。
stm32 自定义串口通信协议
04-01
1. 确定协议格式：包头+数据+校验+包尾。 2. 包头：可以是固定的几个字节，用于标识数据包的开始。 3. 数据：可以是自定义的数据格式，需要根据具体应用场景进行设计。 4. 校验：可以使用CRC、校验和等方式进行数据校验，以提高数据传输的可靠性。 5. 包尾：可以是固定的几个字节，用于标识数据包的结束。 6. 设计数据帧格式：根据数据的类型和长度，设计数据帧的格式，例如可以使用固定长度的数据帧或者可变长度的数据帧。 7. 实现数据发送和接收功能：通过串口发送和接收数据，并进行数据解析和校验。 8. 实现数据处理功能：根据接收到的数据进行相应的处理，例如数据存储、数据显示、控制命令等。 9. 测试和优化：通过测试和优化，保证协议的稳定性和可靠性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

binhaoPro

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值