协议设计练习

最新推荐文章于 2024-04-27 21:54:51 发布

bruceEeZhao

最新推荐文章于 2024-04-27 21:54:51 发布

阅读量908

点赞数

分类专栏： stm32(ebox) 文章标签：设计协议设计 stm32 c 数据

本文链接：https://blog.csdn.net/deltaforce_eagle/article/details/51822480

版权

stm32(ebox) 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

协议说明

数据包头	命令	分片标志	数据	包尾
1字节	1字节	1字节	n字节	2字节

主机—->从机：

包头：0xaa
包尾：0x0d 0x0a
命令：0x01 查询从机状态
0x02 数据请求
0x03 控制命令
发送信息示例：
查询命令：0xaa | 0x01 | 0x00 | 0x0d 0x0a
数据请求：0xaa | 0x02 | 0x00 | 0x0d 0x0a
控制命令：0xaa | 0x03 | 0x00 | 0x01 | 0x00 | 0x0d | 0x0a
(字节编号从0开始)字节3为执行器（0x01led灯，0x02beep，0x03风扇）
字节4为执行器的开关（0x00关，0x01开）

从机—->主机：

包头：0xbb
包尾：0x0d 0x0a
命令：0x01 就绪
0x02 忙
0x03 出错
0x11 命令执行成功
0x12 忙
0x13 命令执行出错，命令不存在
发送信息示例：
0xbb | 0x01 | 0x01 | data | 0x0d 0x0a
0xbb | 0x11 | 0x00 | 0x01 | 0x00 | 0x0d 0x0a
(字节编号从0开始)字节3为执行器（0x01led灯，0x02beep，0x03风扇）
字节4为执行器的状态（0x00关，0x01开）

协议示例

下面是一个stm32f103中蓝牙透传的协议的练习，蓝牙使用串口3。为了简便此协议并没有实现校验。
由于安卓中蓝牙每次接收数据最大长度只有20字节，故将数据包进行拆包，数据报最大长度为20字节。
数据拆包传输完整的实现了，从机状态信息函数void slaveState()没有根据现实的机器信息进行反馈，
只简单返回了一个信息。主机控制从机的部分，采取一次行发送所有控制信息，没有再进行细分。

#ifndef _protocal_H
#define _protocal_H

#include "usart.h"


//包头
#define   HOST_TO_SLAVE_H    0xaa     //主机->从机  包头
#define   SLAVE_TO_HOST_H    0xbb     //从机->主机  包头

#define   MESSAGE_TAIL_F     0x0d     //包尾结束标志  0x0d  0x0a
#define   MESSAGE_TAIL_B     0x0a

#define   DIVIDE_ENABLE      0x01     //有分片
#define   DIVIDE_DISABLE     0x00     //无分片

//主机->从机 命令
#define   HOST_CMD_CHECK     0x01     //查询从机状态
#define   HOST_CMD_READ      0x02     //读取从机数据
#define   HOST_CMD_WRITE     0x03     //向从机中写入数据

//从机->主机 从机状态命令
#define   SLAVE_STA_READY    0x01     //从机准备就绪
#define   SLAVE_STA_BUSY     0x02     //从机忙
#define   SLAVE_STA_ERROR    0x03     //从机出错

//从机->主机 从机执行状态命令
#define   SLAVE_EXU_SUCCE    0x11     //命令执行成功
#define   SLAVE_EXU_BUSY     0x12     //从机忙
#define   SLAVE_EXU_ERROR    0x13     //命令执行出错，命令不存在


//执行器
#define   LEDCONTROL         0x01
#define   BEEPCONTROL        0x02
#define   FANCONTROL         0x03
#define   ONSTATE            0x01     //开
#define   OFFSTATE           0x00     //关

#define   MES_HEAD_LEN      3      //包头长度
#define   MES_TAIL_LEN      2      //包尾长度



enum MixData {
                TMPH, TMPL,         //温度
                HUMH, HUML,         //湿度
                PRETH,PRETL,        // bmp1750 ut值
                PRESH, PRESL,       // bmp1750 up值
                LIGH, LIGL,         //光强 
                PRE_REG_AC1H, PRE_REG_AC1L,      //bmp1750 ac1-ac6,b1,b2,mb-md的值
                PRE_REG_AC2H, PRE_REG_AC2L,
                PRE_REG_AC3H, PRE_REG_AC3L,
                PRE_REG_AC4H, PRE_REG_AC4L,
                PRE_REG_AC5H, PRE_REG_AC5L,
                PRE_REG_AC6H, PRE_REG_AC6L,
                PRE_REG_B1H, PRE_REG_B1L,
                PRE_REG_B2H, PRE_REG_B2L,
                PRE_REG_MBH, PRE_REG_MBL,
                PRE_REG_MCH, PRE_REG_MCL,
                PRE_REG_MDH, PRE_REG_MDL,
                TOTAL_DATA
};

extern unsigned char All_Info_Char[TOTAL_DATA];       //信息数组，将传感器采集的信息放入此数组中，存储次序为上方的MixData表
int messageAnalysis(u8 USART_RX_BUF[USART_REC_LEN]); //报文解析
void slaveState();
void slaveSendM();
void slaveRecM(u8 USART_RX_BUF[USART_REC_LEN]);

#include "protocal.h"
#include "crc16.h"
#include "app.h"
#include "string.h"
#include "delay.h"

unsigned char All_Info_Char[TOTAL_DATA] = {0}; 

int messageAnalysis(u8 USART_RX_BUF[USART_REC_LEN]) //报文解析
{
    if(USART_RX_STA&0x8000) {    //当包尾为0d 0a时进行处理
    if(USART_RX_BUF[1] == HOST_CMD_CHECK) {  
        slaveState();
        USART_RX_STA = 0;
    }else if(USART_RX_BUF[1] == HOST_CMD_READ) {   
        slaveSendM();
        USART_RX_STA = 0;
    }else if(USART_RX_BUF[1] == HOST_CMD_WRITE) { 
        slaveRecM(USART_RX_BUF);
        USART_RX_STA = 0;
    }else{  
        USART_RX_STA = 0;
    }
}
}

void slaveState()
{
    unsigned char message[7] = {0};
    message[0] = SLAVE_TO_HOST_H;
    message[1] = SLAVE_EXU_SUCCE;
    message[2] = DIVIDE_DISABLE;
    message[5] = MESSAGE_TAIL_F;
    message[6] = MESSAGE_TAIL_B;

    message[3] = LEDCONTROL;            //执行器
    message[4] = LedState;           //状态
    USART_SendMessage(USART3, message, 7);
    delay_ms(50);
    message[3] = BEEPCONTROL;           
    message[4] = BeepState;           
    USART_SendMessage(USART3, message, 7);
    delay_ms(50);
    message[3] = FANCONTROL;           
    message[4] = FanState;          
    USART_SendMessage(USART3, message, 7);
    delay_ms(50);
}

void slaveSendM()         //从机向主机发送信息
{
    int i = 0,j = 0, len;
    volatile int  k = 0;
    int totaldata = TOTAL_DATA;
    unsigned char message[TOTAL_DATA+MES_HEAD_LEN+MES_TAIL_LEN] = {0};
    for(i = 0; i < TOTAL_DATA / 15; i++) {   //分片，每片最多20字节
        message[0] = SLAVE_TO_HOST_H;
        message[1] = SLAVE_STA_READY;
        message[2] = DIVIDE_ENABLE;
        for(j = MES_HEAD_LEN; j < 15 + MES_HEAD_LEN; j++, k++) {
            message[j] = All_Info_Char[k]; 
        }
        message[18] = MESSAGE_TAIL_F;
        message[19] = MESSAGE_TAIL_B;
        USART_SendMessage(USART1, message, 20);
        delay_ms(10);
    }
    len = k;
    message[0] = SLAVE_TO_HOST_H;
    message[1] = SLAVE_STA_READY;
    message[2] = DIVIDE_DISABLE;
    for(j = MES_HEAD_LEN; j < TOTAL_DATA+MES_HEAD_LEN - k; j++, k++) {
            message[j] = All_Info_Char[k]; 
    }
    message[TOTAL_DATA+MES_HEAD_LEN+MES_TAIL_LEN -len-2] = MESSAGE_TAIL_F;
    message[TOTAL_DATA+MES_HEAD_LEN+MES_TAIL_LEN - 1-len] = MESSAGE_TAIL_B;
    USART_SendMessage(USART1, message, TOTAL_DATA+MES_HEAD_LEN+MES_TAIL_LEN - len);
}

void slaveRecM(u8 USART_RX_BUF[USART_REC_LEN])
{
//  USART_SendMessage(USART3, "ok3", 3);
    unsigned char message[7] = {0};
        if(USART_RX_BUF[3] == LEDCONTROL) {
            LED_Cont(USART_RX_BUF[4]);
            LedState = USART_RX_BUF[4];
            message[1] = SLAVE_EXU_SUCCE;
        }else if(USART_RX_BUF[3] == BEEPCONTROL) {
            Buzzer_Cont(USART_RX_BUF[4]);
            BeepState = USART_RX_BUF[4];
            message[1] = SLAVE_EXU_SUCCE;
        }else if(USART_RX_BUF[3] == FANCONTROL) {
            Fan_Cont(USART_RX_BUF[4]);
            FanState = USART_RX_BUF[4];
            message[1] = SLAVE_EXU_SUCCE;
        }else {
            message[1] = SLAVE_EXU_ERROR;
        }

    message[0] = SLAVE_TO_HOST_H;

    message[2] = DIVIDE_DISABLE;
    message[3] = USART_RX_BUF[3];            //执行器
    message[4] = USART_RX_BUF[4];            //状态
    message[5] = MESSAGE_TAIL_F;
    message[6] = MESSAGE_TAIL_B;
    USART_SendMessage(USART3, message, 7);
}

串口1的中断处理函数，作用是当判断收到的信息为aa时开始接收，将信息放入USART_RX_BUF数组中，当信息为0d 0a时，结束接收。交与下面进行报文的解析。

#define USART_REC_LEN           200     //定义最大接受字节数 200
u8 USART_RX_BUF[USART_REC_LEN];     //接收缓冲，最大接收USART_REC_LEN个字符
//接收状态
//bit15，    接收完成标志
//bit14，   接收到0x0d
//bit13～0  接收到的有效字节数
u16 USART_RX_STA=0;       //接收状态标记  
u16 USART_RX_S_STA=0;     //帧起始标志

void USART1_IRQHandler(void)                                         //串口1中断服务程序
{

    uint16_t Res;
    if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)            //接收中断（aa开始0d0a结束）
    {
        Res =USART_ReceiveData(USART1);                                //(USART1->DR);  //读取收到的数据
    //  USART_SendData(USART1,Res);
        if(Res == HOST_TO_SLAVE_H && USART_RX_S_STA == 0) {  //包头标志0xaa 
            USART_RX_S_STA = 1;
        }
        if(USART_RX_S_STA) {
            if((USART_RX_STA&0x8000)==0)                                   //接收未完成
            {
                if(USART_RX_STA&0x4000)                                      //接收到0x0d
                {
                    if(Res!=0x0a)USART_RX_STA=0;                               //接收错误，重新开始
                    else {
                        USART_RX_STA|=0x8000;                                  //接收完成           //bit31表明是否接收到0x0a
                        USART_RX_BUF[USART_RX_STA&0X3FFF]= '\0';
                        USART_RX_S_STA = 0;
                    }
                }
                else //还没接收到0x0d
                {   
                    if(Res==0x0d) USART_RX_STA|=0x4000;                     //bit30表明是否接收到0x0d
                    else
                    {
                        USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
                        USART_RX_STA++;
                        if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误，重新开始接收  
                    }        
                }
            }       //   printf("%s", USART_RX_BUF);
        }
  } 


void USART_SendMessage(USART_TypeDef* USARTx, u8 *buf, u8 len) 
{
    u8 i;
  for (i = 0; i < len; i++)  {
        USART_SendData(USARTx,buf[i]);
        while (USART_GetFlagStatus(USARTx, USART_FLAG_TC) == RESET) {}  
    }
}