[ARM入门]MQTT协议连接阿里云

使用STM32F103为主控芯片，通过AT指令和TCP MQTT协议，连接到阿里云。
主函数
首先，初始化基础外设及数组、参数等。

       delay_init();                     //延时函数初始化          LED_Init();                          //初始化与LED连接的硬件接口uart1_init(115200);uart2_init(115200);TIM4_Init(300,7200);            //TIM4初始化，定时时间 300*7200*1000/72000000 = 30msLED_Init();                            //LED初始化WiFi_ResetIO_Init();//ESP8266复位MQTT_Buff_Init();               //初始化接收,发送,命令数据的 缓冲区 以及各状态参数AliIoT_Parameter_Init();//阿里云初始化参数

进入while函数首先判断Connect_flag是否等于1，Connect_flag是与服务器的连接状态。若等于1，则WIFI已经连接上网络。
然后判断发送数组的存放指针和读取是否相等，如果不相等，则数组中有数据等待发送。
最后发送数据并将指针下移。

 /*--------------------------------------------------------------------*//*   Connect_flag=1同服务器建立了连接,我们可以发布数据和接收推送了    *//*--------------------------------------------------------------------*/if(Connect_flag==1){     /*-------------------------------------------------------------*//*                     处理发送缓冲区数据                      *//*-------------------------------------------------------------*/if(MQTT_TxDataOutPtr != MQTT_TxDataInPtr){                //if成立的话，说明发送缓冲区有数据了//3种情况可进入if//第1种：0x10 连接报文//第2种：0x82 订阅报文，且ConnectPack_flag置位，表示连接报文成功//第3种：SubcribePack_flag置位，说明连接和订阅均成功，其他报文可发if((MQTT_TxDataOutPtr[2]==0x10)||((MQTT_TxDataOutPtr[2]==0x82)&&(ConnectPack_flag==1))||(SubcribePack_flag==1)){    u2_printf("发送数据:0x%x\r\n",MQTT_TxDataOutPtr[2]);  //串口提示信息MQTT_TxData(MQTT_TxDataOutPtr);                       //发送数据MQTT_TxDataOutPtr += BUFF_UNIT;                       //指针下移if(MQTT_TxDataOutPtr==MQTT_TxDataEndPtr)              //如果指针到缓冲区尾部了MQTT_TxDataOutPtr = MQTT_TxDataBuf[0];            //指针归位到缓冲区开头}                                 }//处理发送缓冲区数据的else if分支结尾  

处理CONNECT报文判断固定报头是否为0x20，如果是0x20，则根据报文说明判断有效载荷，返回00则是连接成功，其余则为失败。

/*-----------------------------------------------------*//*                    处理CONNACK报文                  *//*-----------------------------------------------------*/                                //if判断，如果第一个字节是0x20，表示收到的是CONNACK报文//接着我们要判断第4个字节，看看CONNECT报文是否成功if(MQTT_RxDataOutPtr[2]==0x20){                                     switch(MQTT_RxDataOutPtr[5]){                                        case 0x00 : u2_printf("CONNECT报文成功\r\n");                            //串口输出信息        ConnectPack_flag = 1;                                        //CONNECT报文成功，订阅报文可发break;                                                       //跳出分支case 0x00                                              case 0x01 : u2_printf("连接已拒绝，不支持的协议版本，准备重启\r\n");     //串口输出信息Connect_flag = 0;                                            //Connect_flag置零，重启连接break;                                                       //跳出分支case 0x01   case 0x02 : u2_printf("连接已拒绝，不合格的客户端标识符，准备重启\r\n"); //串口输出信息Connect_flag = 0;                                            //Connect_flag置零，重启连接break;                                                       //跳出分支case 0x02 case 0x03 : u2_printf("连接已拒绝，服务端不可用，准备重启\r\n");         //串口输出信息Connect_flag = 0;                                            //Connect_flag置零，重启连接break;                                                       //跳出分支case 0x03case 0x04 : u2_printf("连接已拒绝，无效的用户名或密码，准备重启\r\n");   //串口输出信息Connect_flag = 0;                                            //Connect_flag置零，重启连接                                                break;                                                       //跳出分支case 0x04case 0x05 : u2_printf("连接已拒绝，未授权，准备重启\r\n");               //串口输出信息Connect_flag = 0;                                            //Connect_flag置零，重启连接                                                break;                                                       //跳出分支case 0x05                 default   : u2_printf("连接已拒绝，未知状态，准备重启\r\n");             //串口输出信息 Connect_flag = 0;                                            //Connect_flag置零，重启连接                                        break;                                                       //跳出分支case default                                                                 }                                }                        

如果固定报头是0x90，则为SUBACK订阅返回报文，根据报文说明判断是否连接成功。

//if判断，第一个字节是0x90，表示收到的是SUBACK报文//接着我们要判断订阅回复，看看是不是成功else if(MQTT_RxDataOutPtr[2]==0x90){ switch(MQTT_RxDataOutPtr[6]){                                        case 0x00 :case 0x01 : u2_printf("订阅成功\r\n");            //串口输出信息SubcribePack_flag = 1;                //SubcribePack_flag置1，表示订阅报文成功，其他报文可发送Ping_flag = 0;                        //Ping_flag清零TIM3_ENABLE_30S();                    //启动30s的PING定时器TIM2_ENABLE_30S();                    //启动30s的上传数据的定时器TempHumi_State();                     //先发一次数据break;                                //跳出分支                                             default   : u2_printf("订阅失败，准备重启\r\n");  //串口输出信息 Connect_flag = 0;                     //Connect_flag置零，重启连接break;                                //跳出分支                                                                 }                                        }

如果固定报头是0x0D，则该报文是PINGRESP报文，这个只需要根据标志位（PING报文发送次数来修改定时器3相关参数即可），有效载荷不用管。

//if判断，第一个字节是0xD0，表示收到的是PINGRESP报文else if(MQTT_RxDataOutPtr[2]==0xD0){ u2_printf("PING报文回复\r\n");                   //串口输出信息 if(Ping_flag==1){                     //如果Ping_flag=1，表示第一次发送Ping_flag = 0;                                      //要清除Ping_flag标志}else if(Ping_flag>1){                                   //如果Ping_flag>1，表示是多次发送了，而且是2s间隔的快速发送Ping_flag = 0;                                       //要清除Ping_flag标志TIM3_ENABLE_30S();                                   //PING定时器重回30s的时间}                                }        

如果固定报头是0x30，则是云端下发的数据，需使用MQTT_DealPushdata_Qs0 //处理等级0推送数据函数来进行处理，并将其有效载荷拆解并放入到命令数组。

    //if判断，如果第一个字节是0x30，表示收到的是服务器发来的推送数据//我们要提取控制命令else if((MQTT_RxDataOutPtr[2]==0x30)){ u2_printf("服务器等级0推送\r\n");                    //串口输出信息 MQTT_DealPushdata_Qs0(MQTT_RxDataOutPtr);  //处理等级0推送数据}                                                          MQTT_RxDataOutPtr += BUFF_UNIT;                     //指针下移if(MQTTT_RxDataOutPtr==MQTT_RxDataEndPtr)            //如果指针到缓冲区尾部了MQTT_RxDataOutPtr = MQTT_RxDataBuf[0];          //指针归位到缓冲区开头                        }//处理接收缓冲区数据的else if分支结尾

命令缓冲区的存放指针和读取指针不相等，则是有命令数据，需要进行处理。

  /*-------------------------------------------------------------*//*                     处理命令缓冲区数据                      *//*-------------------------------------------------------------*/if(MQTT_CMDOutPtr != MQTT_CMDInPtr){                             //if成立的话，说明命令缓冲区有数据了                               u2_printf("命令:%s\r\n",&MQTT_CMDOutPtr[2]);                 //串口输出信息if(strstr((char *)MQTT_CMDOutPtr+2,"\params\":{\"PowerSwitch\":1}")){LED1_ON;LED1_State();}else if(strstr((char *)MQTT_CMDOutPtr+2,"\params\":{\"PowerSwitch\":0}")){LED1_OFF;LED1_State();}MQTT_CMDOutPtr += BUFF_UNIT;                                      //指针下移if(MQTT_CMDOutPtr==MQTT_CMDEndPtr)                                //如果指针到缓冲区尾部了MQTT_CMDOutPtr = MQTT_CMDBuf[0];                               //指针归位到缓冲区开头                                }//处理命令缓冲区数据的else if分支结尾        }//Connect_flag=1的if分支的结尾

如果Connect_flag标志位等于0，则认为设备与服务器断开连接，则需要重启服务器。

/*--------------------------------------------------------------------*//*      Connect_flag=0同服务器断开了连接,我们要重启连接服务器         *//*--------------------------------------------------------------------*/else{ u2_printf("需要连接服务器\r\n");                 //串口输出信息TIM_Cmd(TIM4,DISABLE);                           //关闭TIM4 TIM_Cmd(TIM3,DISABLE);                           //关闭TIM3  WiFi_RxCounter=0;                                //WiFi接收数据量变量清零                        memset(WiFi_RX_BUF,0,WiFi_RXBUFF_SIZE);          //清空WiFi接收缓冲区 if(WiFi_Connect_IoTServer()==0){                                //如果WiFi连接云服务器函数返回0，表示正确，进入ifu2_printf("建立TCP连接成功\r\n");            //串口输出信息Connect_flag = 1;                            //Connect_flag置1，表示连接成功        WiFi_RxCounter=0;                            //WiFi接收数据量变量清零                        memset(WiFi_RX_BUF,0,WiFi_RXBUFF_SIZE);      //清空WiFi接收缓冲区 MQTT_Buff_ReInit();                          //重新初始化发送缓冲区                    }                                
串口配置
1.使用串口1为数据发送和接收串口，使用串口2为调试打印串口，方便外部查看程序运行节点以及错误信息。
串口1配置

void uart1_init(u32 bound){//GPIO端口设置GPIO_InitTypeDef GPIO_InitStructure;USART_InitTypeDef USART_InitStructure;#if EN_USART1_RX   //如果使能了接收         NVIC_InitTypeDef NVIC_InitStructure;     //如果使能接收功能，定义一个设置中断的变量NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);  //设置中断向量分组：第2组 抢先优先级：0 1 2 3 子优先级：0 1 2 3#endif        RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_AFIO, ENABLE);        //使能USART1，GPIOA时钟//USART1_TX   GPIOA.9GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;        //复用推挽输出GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9//USART1_RX          GPIOA.10初始化GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10  //USART 初始化设置USART_InitStructure.USART_BaudRate = bound;//串口波特率USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制#if EN_USART1_RXUSART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        //收发模式#elseUSART_InitStructure.USART_Mode = USART_Mode_Tx ;                       //只发模式#endifUSART_Init(USART1, &USART_InitStructure); //初始化串口1#if EN_USART1_RX                                                                                                           //如果使能接收模式//Usart1 NVIC 配置USART_ClearFlag(USART1, USART_FLAG_RXNE);                    //清除接收标志位USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);          //开启接收中断NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0 ;//抢占优先级0NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;                //子优先级0NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器#endif        USART_Cmd(USART1, ENABLE);                    //使能串口1 }

串口1发送数据代码

/*-------------------------------------------------*//*函数名：串口1发送缓冲区中的数据                  *//*参  数：data：数据                               *//*返回值：无                                       *//*-------------------------------------------------*/void u1_TxData(unsigned char *data){int        i;        while((USART1->SR&0X40)==0);for(i = 1;i <= (data[0]*156+data[1]);i ++){                        USART1->DR = data[i+1];while((USART1->SR&0X40)==0);        }}

串口1中断函数

void USART1_IRQHandler(void)                        //串口1中断服务程序{        if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET){  //如果USART_IT_RXNE标志置位，表示有数据到了，进入if分支if(Connect_flag==0){                                //如果Connect_flag等于0，当前还没有连接服务器，处于指令配置状态if(USART1->DR){                                 //处于指令配置状态时，非零值才保存到缓冲区        Usart1_RxBuff[Usart1_RxCounter]=USART1->DR; //保存到缓冲区        Usart1_RxCounter ++;                        //每接收1个字节的数据，Usart1_RxCounter加1，表示接收的数据总量+1 }                }else{                                                        //反之Connect_flag等于1，连接上服务器了        Usart1_RxBuff[Usart1_RxCounter] = USART1->DR;   //把接收到的数据保存到Usart1_RxBuff中                                if(Usart1_RxCounter == 0){                                            //如果Usart1_RxCounter等于0，表示是接收的第1个数据，进入if分支                                TIM_Cmd(TIM4,ENABLE); }else{                                                                //else分支，表示果Usart1_RxCounter不等于0，不是接收的第一个数据TIM_SetCounter(TIM4,0);  }        Usart1_RxCounter ++;                                             //每接收1个字节的数据，Usart1_RxCounter加1，表示接收的数据总量+1 }}}

串口2配置

void uart2_init(u32 bound){//GPIO端口设置GPIO_InitTypeDef GPIO_InitStructure;USART_InitTypeDef USART_InitStructure;#if EN_USART1_RX   //如果使能了接收         NVIC_InitTypeDef NVIC_InitStructure;     //如果使能接收功能，定义一个设置中断的变量NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);  //设置中断向量分组：第2组 抢先优先级：0 1 2 3 子优先级：0 1 2 3#endif        RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_AFIO, ENABLE);        //使能USART2，GPIOA时钟//USART2_TX   GPIOA.9GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2; //PA.2GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;        //复用推挽输出GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.2//USART2_RX          GPIOA.10初始化GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;//PA3GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10  //USART 初始化设置USART_InitStructure.USART_BaudRate = bound;//串口波特率USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制#if EN_USART2_RXUSART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        //收发模式#else USART_InitStructure.USART_Mode = USART_Mode_Tx ;                                   //只发模式#endifUSART_Init(USART2, &USART_InitStructure); //初始化串口2#if EN_USART2_RX//Usart2 NVIC 配置USART_ClearFlag(USART2, USART_FLAG_RXNE);                    //清除接收标志位USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);//开启串口接受中断NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0 ;//抢占优先级3NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;                //子优先级3NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器#endifUSART_Cmd(USART2, ENABLE);                    //使能串口2 }

串口2打印函数

/*-------------------------------------------------*//*函数名：串口2 printf函数                         *//*参  数：char* fmt,...  格式化输出字符串和参数    *//*返回值：无                                       *//*-------------------------------------------------*/__align(8) char Usart2_TxBuff[USART_MAX_LEN];  void u2_printf(char* fmt,...) {  unsigned int i,length;va_list ap;va_start(ap,fmt);vsprintf(Usart2_TxBuff,fmt,ap);va_end(ap);        length=strlen((const char*)Usart2_TxBuff);                while((USART2->SR&0X40)==0);for(i = 0;i < length;i ++){                        USART2->DR = Usart2_TxBuff[i];while((USART2->SR&0X40)==0);        }        }

2.定时器配置
配置定时器  3个，中断程序如下：
定时器4，在串口1接收到数据后触发串口中断，串口中断会将定时器4使能，将接收到的数据从串口寄存器中拷贝到指定的接收数组中，方便使用。

/*-------------------------------------------------*//*函数名：定时器4中断服务函数                      *//*参  数：无                                       *//*返回值：无                                       *//*-------------------------------------------------*/void TIM4_IRQHandler(void){if(TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET){                //如果TIM_IT_Update置位，表示TIM4溢出中断，进入if        memcpy(&MQTT_RxDataInPtr[2],Usart1_RxBuff,Usart1_RxCounter);  //拷贝数据到接收缓冲区MQTT_RxDataInPtr[0] = Usart1_RxCounter/256;                   //记录数据长度高字节MQTT_RxDataInPtr[1] = Usart1_RxCounter%256;                   //记录数据长度低字节MQTT_RxDataInPtr+=BUFF_UNIT;                                  //指针下移if(MQTT_RxDataInPtr==MQTT_RxDataEndPtr)                       //如果指针到缓冲区尾部了MQTT_RxDataInPtr = MQTT_RxDataBuf[0];                     //指针归位到缓冲区开头Usart1_RxCounter = 0;                                         //串口2接收数据量变量清零TIM_SetCounter(TIM3, 0);                                      //清零定时器3计数器，重新计时ping包发送时间TIM_Cmd(TIM4, DISABLE);                                                          //关闭TIM4定时器TIM_SetCounter(TIM4, 0);                                                  //清零定时器4计数器TIM_ClearITPendingBit(TIM4, TIM_IT_Update);                               //清除TIM4溢出中断标志         }}

定时器3中断函数，如果发送PING报文接收错误或无接收（断开），使能定时器3，在短时间内多次发送PING报文，如果是有回复，则关闭定时器3，如果还是没有回复，则认为连接断开，将PING连接标志位清除后关闭定时器3.

/*-------------------------------------------------*//*函数名：定时器3中断服务函数                      *//*参  数：无                                       *//*返回值：无                                       *//*-------------------------------------------------*/void TIM3_IRQHandler(void){if(TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET){   //如果TIM_IT_Update置位，表示TIM3溢出中断，进入if        switch(Ping_flag){                               //判断Ping_flag的状态case 0:                                                                                 //如果Ping_flag等于0，表示正常状态，发送Ping报文  MQTT_PingREQ();                                          //添加Ping报文到发送缓冲区  break;case 1:                                                                                 //如果Ping_flag等于1，说明上一次发送到的ping报文，没有收到服务器回复，所以1没有被清除为0，可能是连接异常，我们要启动快速ping模式TIM3_ENABLE_2S();                                          //我们将定时器6设置为2s定时,快速发送Ping报文MQTT_PingREQ();                                           //添加Ping报文到发送缓冲区  break;case 2:                                                                                 //如果Ping_flag等于2，说明还没有收到服务器回复case 3:                                                         //如果Ping_flag等于3，说明还没有收到服务器回复case 4:                                                         //如果Ping_flag等于4，说明还没有收到服务器回复        MQTT_PingREQ();                                           //添加Ping报文到发送缓冲区 break;case 5:                                                                                 //如果Ping_flag等于5，说明我们发送了多次ping，均无回复，应该是连接有问题，我们重启连接Connect_flag = 0;                    //连接状态置0，表示断开，没连上服务器TIM_Cmd(TIM3,DISABLE);               //关TIM3                                 break;                        }Ping_flag++;                                                         //Ping_flag自增1，表示又发送了一次ping，期待服务器的回复TIM_ClearITPendingBit(TIM3, TIM_IT_Update);      //清除TIM3溢出中断标志         }}

定时器2，在连接到阿里云平台后使能，定时发送数据。

/*-------------------------------------------------*//*函数名：定时器2中断服务函数                      *//*参  数：无                                       *//*返回值：无                                       *//*-------------------------------------------------*/void TIM2_IRQHandler(void){        if(TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET){  //如果TIM_IT_Update置位，表示TIM2溢出中断，进入if        TempHumi_State();TIM_ClearITPendingBit(TIM2, TIM_IT_Update);     //清除TIM2溢出中断标志         }}

3.ESP8266配置
通过串口1和串口2的功能，使用AT指令来操作ESP8266，实现相应功能。
复位引脚配置

/*-------------------------------------------------*//*函数名：初始化WiFi的复位IO                       *//*参  数：无                                       *//*返回值：无                                       *//*-------------------------------------------------*/void WiFi_ResetIO_Init(void){GPIO_InitTypeDef GPIO_InitStructure;                      //定义一个设置IO端口参数的结构体RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOC , ENABLE);   //使能PA端口时钟GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;                 //准备设置PC13GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;         //速率50MhzGPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                     //推免输出方式GPIO_Init(GPIOC, &GPIO_InitStructure);                              //设置PC13RESET_IO=1;                                              //复位IO拉高电平}

WIFI复位函数

/*-------------------------------------------------*//*函数名：WiFi复位                                 *//*参  数：timeout：超时时间（100ms的倍数）         *//*返回值：0：正确   其他：错误                     *//*-------------------------------------------------*/char WiFi_Reset(int timeout){RESET_IO=0;                                    //复位IO拉低电平delay_ms(500);                                  //延时500msRESET_IO=1;                                    //复位IO拉高电平        while(timeout--){                               //等待超时时间到0delay_ms(100);                              //延时100msif(strstr(WiFi_RX_BUF,"ready"))             //如果接收到ready表示复位成功break;                                                           //主动跳出while循环u2_printf("%d ",timeout);                   //串口输出现在的超时时间}u2_printf("\r\n");                              //串口输出信息if(timeout<=0)return 1;                         //如果timeout<=0，说明超时时间到了，也没能收到ready，返回1else return 0;                                                             //反之，表示正确，说明收到ready，通过break主动跳出while}

WIFI发送AT指令

/*-------------------------------------------------*//*函数名：WiFi发送设置指令                         *//*参  数：cmd：指令                                *//*参  数：timeout：超时时间（100ms的倍数）         *//*返回值：0：正确   其他：错误                     *//*-------------------------------------------------*/char WiFi_SendCmd(char *cmd, int timeout){WiFi_RxCounter=0;                           //WiFi接收数据量变量清零                        memset(WiFi_RX_BUF,0,WiFi_RXBUFF_SIZE);     //清空WiFi接收缓冲区 WiFi_printf("%s\r\n",cmd);                  //发送指令while(timeout--){                           //等待超时时间到0delay_ms(100);                          //延时100msif(strstr(WiFi_RX_BUF,"OK"))            //如果接收到OK表示指令成功break;                                                       //主动跳出while循环u1_printf("%d ",timeout);               //串口输出现在的超时时间}u1_printf("\r\n");                          //串口输出信息if(timeout<=0)return 1;                     //如果timeout<=0，说明超时时间到了，也没能收到OK，返回1else return 0;                                                         //反之，表示正确，说明收到OK，通过break主动跳出while}

WIFI发送TCP指令，通过发送预先设置的WIFI名称和密码，连接到网络。

/*-------------------------------------------------*//*函数名：连接TCP服务器，并进入透传模式            *//*参  数：timeout： 超时时间（100ms的倍数）        *//*返回值：0：正确  其他：错误                      *//*-------------------------------------------------*/char WiFi_Connect_Server(int timeout){        WiFi_RxCounter=0;                               //WiFi接收数据量变量清零                        memset(WiFi_RX_BUF,0,WiFi_RXBUFF_SIZE);         //清空WiFi接收缓冲区   WiFi_printf("AT+CIPSTART=\"TCP\",\"%s\",%d\r\n",ServerIP,ServerPort);//发送连接服务器指令while(timeout--){                               //等待超时与否delay_ms(100);                              //延时100ms        if(strstr(WiFi_RX_BUF ,"CONNECT"))          //如果接受到CONNECT表示连接成功break;                                  //跳出while循环if(strstr(WiFi_RX_BUF ,"CLOSED"))           //如果接受到CLOSED表示服务器未开启return 1;                               //服务器未开启返回1if(strstr(WiFi_RX_BUF ,"ALREADY CONNECTED"))//如果接受到ALREADY CONNECTED已经建立连接return 2;                               //已经建立连接返回2u2_printf("%d ",timeout);                   //串口输出现在的超时时间  }u2_printf("\r\n");                        //串口输出信息if(timeout<=0)return 3;                   //超时错误，返回3else                                      //连接成功，准备进入透传{u2_printf("连接服务器成功，准备进入透传\r\n");  //串口显示信息WiFi_RxCounter=0;                               //WiFi接收数据量变量清零                        memset(WiFi_RX_BUF,0,WiFi_RXBUFF_SIZE);         //清空WiFi接收缓冲区     WiFi_printf("AT+CIPSEND\r\n");                  //发送进入透传指令while(timeout--){                               //等待超时与否delay_ms(100);                              //延时100ms        if(strstr(WiFi_RX_BUF,"\r\nOK\r\n\r\n>"))   //如果成立表示进入透传成功break;                          //跳出while循环u2_printf("%d ",timeout);           //串口输出现在的超时时间  }if(timeout<=0)return 4;                 //透传超时错误，返回4        }return 0;                                        //成功返回0        }

WIFI初始化配置，通过使用编写的函数和AT指令，来连接到指定服务器。
1.复位检查模块
2.发送AT指令检查模块
3.设置ESP8266模式  
4.连接到WIFI
5.设置透传
6.连接到指定服务器

*-------------------------------------------------*//*函数名：WiFi连接服务器                           *//*参  数：无                                       *//*返回值：0：正确   其他：错误                     *//*-------------------------------------------------*/char WiFi_Connect_IoTServer(void){        /*             复位模块                */u2_printf("准备复位模块\r\n");                     //串口提示数据if(WiFi_Reset(50)){                                //复位，100ms超时单位，总计5s超时时间u2_printf("复位失败，准备重启\r\n");           //返回非0值，进入if，串口提示数据return 1;                                      //返回1}else u2_printf("复位成功\r\n");                   //串口提示数据/*             连接模块                */u2_printf("准备连接模块\r\n");                     //串口提示数据if(WiFi_SendCmd("AT",30)){                        //复位，100ms超时单位，总计5s超时时间u2_printf("连接失败，请检查模块\r\n");           //返回非0值，进入if，串口提示数据return 1;                                      //返回1}else u2_printf("连接成功\r\n");                   //串口提示数据/*             设置模式                */        u2_printf("准备设置STA模式\r\n");                  //串口提示数据if(WiFi_SendCmd("AT+CWMODE=3",50)){                //设置STA模式，100ms超时单位，总计5s超时时间u2_printf("设置STA模式失败，准备重启\r\n");    //返回非0值，进入if，串口提示数据return 2;                                      //返回2}else u2_printf("设置STA模式成功\r\n");            //串口提示数据/*             连接WiFi                */                u2_printf("准备连接路由器\r\n");                   //串口提示数据        if(WiFi_JoinAP(30)){                               //连接路由器,1s超时单位，总计30s超时时间u2_printf("连接路由器失败，准备重启\r\n");     //返回非0值，进入if，串口提示数据return 3;                                      //返回3        }else u2_printf("连接路由器成功\r\n");             //串口提示数据                        /*             设置透传                */                u2_printf("准备设置透传\r\n");                     //串口提示数据if(WiFi_SendCmd("AT+CIPMODE=1",50)){               //设置透传，100ms超时单位，总计5s超时时间u2_printf("设置透传失败，准备重启\r\n");       //返回非0值，进入if，串口提示数据return 4;                                      //返回4}else u2_printf("设置透传成功\r\n");               //串口提示数据/*             连接服务器                */                u1_printf("准备连接服务器\r\n");                   //串口提示数据if(WiFi_Connect_Server(100)){                      //连接服务器，100ms超时单位，总计10s超时时间u2_printf("连接服务器失败，准备重启\r\n");     //返回非0值，进入if，串口提示数据return 10;                                     //返回10}else u2_printf("连接服务器成功\r\n");             //串口提示数据        return 0;                                          //正确返回0}

4.MQTT协议及配置
MQTT连接到服务器、发送数据 需要构建三个报文
1.使用CONNECT连接报文,和阿里云建立连接.
2.发布SUBSCRIBE订阅报文,订阅相关主题.
3.使用PUBLISH发布报文,向阿里云发送消息

使用三组二维数组来存放接收数据、发送数据、筛选指令，并通过三组指针来操作三组数据。

unsigned char  MQTT_RxDataBuf[R_NUM][BUFF_UNIT];            //数据的接收缓冲区,所有服务器发来的数据，存放在该缓冲区,缓冲区第一个字节存放数据长度unsigned char *MQTT_RxDataInPtr;                            //指向接收缓冲区存放数据的位置unsigned char *MQTT_RxDataOutPtr;                           //指向接收缓冲区读取数据的位置unsigned char *MQTT_RxDataEndPtr;                           //指向接收缓冲区结束的位置unsigned char  MQTT_TxDataBuf[T_NUM][BUFF_UNIT];            //数据的发送缓冲区,所有发往服务器的数据，存放在该缓冲区,缓冲区第一个字节存放数据长度unsigned char *MQTT_TxDataInPtr;                            //指向发送缓冲区存放数据的位置unsigned char *MQTT_TxDataOutPtr;                           //指向发送缓冲区读取数据的位置unsigned char *MQTT_TxDataEndPtr;                           //指向发送缓冲区结束的位置unsigned char  MQTT_CMDBuf[C_NUM][BUFF_UNIT];               //命令数据的接收缓冲区unsigned char *MQTT_CMDInPtr;                               //指向命令缓冲区存放数据的位置unsigned char *MQTT_CMDOutPtr;                              //指向命令缓冲区读取数据的位置unsigned char *MQTT_CMDEndPtr;                              //指向命令缓冲区结束的位置

定义四个标志位变量，来判断ESP8266的连接状态。

char Connect_flag;        //同服务器连接状态  0：还没有连接服务器  1：连接上服务器了char Ping_flag;           //ping报文状态      0：正常状态，等待计时时间到，发送Ping报文//ping报文状态      1：Ping报文已发送，当收到 服务器回复报文的后 将1置为0char ConnectPack_flag;    //CONNECT报文状态   1：CONNECT报文成功char SubcribePack_flag;   //订阅报文状态      1：订阅报文成功

定义用户ID、用户名、密码、服务器IP端口变量。

char ClientID[128];                                          //存放客户端ID的缓冲区int  ClientID_len;                                           //存放客户端ID的长度char Username[128];                                          //存放用户名的缓冲区int  Username_len;                                                                                         //存放用户名的长度char Passward[128];                                          //存放密码的缓冲区int  Passward_len;                                                                                         //存放密码的长度char ServerIP[128];                                          //存放服务器IP或是域名int  ServerPort;                                             //存放服务器的端口号

定义长度变量，方便计算数据长度

int   Fixed_len;                                                                    //固定报头长度int   Variable_len;                                                              //可变报头长度int   Payload_len;                                                                //有效负荷长度unsigned char  temp_buff[BUFF_UNIT];                                                 //临时缓冲区，构建报文用

数据数组指针初始化函数

/*----------------------------------------------------------*//*函数名：初始化接收,发送,命令数据的 缓冲区 以及各状态参数  *//*参  数：无                                                *//*返回值：无                                                *//*----------------------------------------------------------*//* 自己的注释：按视频讲解来看，是in指针和out两个指针，两个指针指向的位置不同的时候就发送数据，相同的时候就不再发送数据  *//*----------------------------------------------------------*/void MQTT_Buff_Init(void){        MQTT_RxDataInPtr=MQTT_RxDataBuf[0];               //指向发送缓冲区存放数据的指针归位MQTT_RxDataOutPtr=MQTT_RxDataInPtr;               //指向发送缓冲区读取数据的指针归位MQTT_RxDataEndPtr=MQTT_RxDataBuf[R_NUM-1];        //指向发送缓冲区结束的指针归位 8-1=7 MQTT_TxDataInPtr=MQTT_TxDataBuf[0];               //指向发送缓冲区存放数据的指针归位MQTT_TxDataOutPtr=MQTT_TxDataInPtr;               //指向发送缓冲区读取数据的指针归位MQTT_TxDataEndPtr=MQTT_TxDataBuf[T_NUM-1];        //指向发送缓冲区结束的指针归位 8-1=7 MQTT_CMDInPtr=MQTT_CMDBuf[0];                     //指向命令缓冲区存放数据的指针归位MQTT_CMDOutPtr=MQTT_CMDInPtr;                     //指向命令缓冲区读取数据的指针归位MQTT_CMDEndPtr=MQTT_CMDBuf[C_NUM-1];              //指向命令缓冲区结束的指针归位 8-1=7 Connect_flag = 0;                                      //各个参数清零Ping_flag = ConnectPack_flag = SubcribePack_flag = 0;  //各个参数清零}

断开连接后重新初始化数据数组指针函数

/*----------------------------------------------------------*//*函数名：重新初始化接收,发送,命令缓冲区 以及各状态参数     *//*参  数：无                                                *//*返回值：无                                                *//*----------------------------------------------------------*/void MQTT_Buff_ReInit(void){                        unsigned char *MQTT_TxDatatempPtr;                 //指向发送缓冲区位置的临时指针if(MQTT_TxDataOutPtr != MQTT_TxDataInPtr){         //if成立的话，说明发送缓冲区有数据了MQTT_TxDataOutPtr = MQTT_TxDataInPtr;          //OUT指针指向IN指针if(MQTT_TxDataOutPtr==MQTT_TxDataBuf[0]){      //如果，现在OUT指针在缓冲区顶部，进入ifMQTT_TxDataOutPtr =MQTT_TxDataBuf[T_NUM-4];//重定位OUT指针}else if(MQTT_TxDataOutPtr==MQTT_TxDataBuf[1]){//如果，现在OUT指针在缓冲区顶部下一个单元，进入ifMQTT_TxDataOutPtr =MQTT_TxDataBuf[T_NUM-3];//重定位OUT指针}else if(MQTT_TxDataOutPtr==MQTT_TxDataBuf[2]){//如果，现在OUT指针在缓冲区顶部下两个单元，进入ifMQTT_TxDataOutPtr =MQTT_TxDataBuf[T_NUM-2];//重定位OUT指针}else{MQTT_TxDataOutPtr -= BUFF_UNIT;            //OUT指针上移一个单元MQTT_TxDataOutPtr -= BUFF_UNIT;            //OUT指针上移一个单元MQTT_TxDataOutPtr -= BUFF_UNIT;            //OUT指针上移一个单元}                        MQTT_TxDatatempPtr = MQTT_TxDataInPtr;         //将当前IN指针的位置暂存在temp指针中MQTT_TxDataInPtr = MQTT_TxDataOutPtr;          //IN指针指向当前OUT指针MQTT_ConectPack();                             //发送缓冲区添加连接报文MQTT_Subscribe(S_TOPIC_NAME,0);                       //发送缓冲区添加订阅topic，等级0                                                                        MQTT_TxDataInPtr = MQTT_TxDatatempPtr;         //IN指针通过temp指针，返回原来的位置                        }else{                                             //反之，说明发送缓冲区没有数据MQTT_ConectPack();                             //发送缓冲区添加连接报文MQTT_Subscribe(S_TOPIC_NAME,0);                       //发送缓冲区添加订阅topic，等级0                                                }Ping_flag = ConnectPack_flag = SubcribePack_flag = 0;  //各个参数清零}

阿里云初始化参数，使用是sprintf函数将字符串拼接，并放到指定变量。

/*----------------------------------------------------------*//*函数名：阿里云初始化参数，得到客户端ID，用户名和密码      *//*参  数：无                                                *//*返回值：无                                                *//*----------------------------------------------------------*/void AliIoT_Parameter_Init(void){        char temp[128];                                                       //计算加密的时候，临时使用的缓冲区memset(ClientID,0,128);                                               //客户端ID的缓冲区全部清零sprintf(ClientID,"%s|securemode=3,signmethod=hmacmd5|",DEVICENAME);  //构建客户端ID，并存入缓冲区ClientID_len = strlen(ClientID);                                      //计算客户端ID的长度memset(Username,0,128);                                               //用户名的缓冲区全部清零sprintf(Username,"%s&%s",DEVICENAME,PRODUCTKEY);                      //构建用户名，并存入缓冲区Username_len = strlen(Username);                                      //计算用户名的长度memset(Passward,0,128);memset(temp,0,128);                                                                      //临时缓冲区全部清零sprintf(temp,"clientId%sdeviceName%sproductKey%s",DEVICENAME,DEVICENAME,PRODUCTKEY);     //构建加密时的明文   utils_hmac_md5(temp,strlen(temp),Passward,DEVICESECRE,DEVICESECRE_LEN);                 //以DeviceSecret为秘钥对temp中的明文，进行hmacsha1加密，结果就是密码，并保存到缓冲区中clientId  D001  deviceName  D001  productKey  i5drb0tO5liPassward_len = strlen(Passward);                                                         //计算用户名的长度memset(ServerIP,0,128);  sprintf(ServerIP,"%s.iot-as-mqtt.cn-shanghai.aliyuncs.com",PRODUCTKEY);                  //构建服务器域名ServerPort = 1883;                                                                       //服务器端口号1883u2_printf("服 务 器：%s:%d\r\n",ServerIP,ServerPort); //串口输出调试信息u2_printf("客户端ID：%s\r\n",ClientID);               //串口输出调试信息u2_printf("用 户 名：%s\r\n",Username);               //串口输出调试信息u2_printf("密    码：%s\r\n",Passward);               //串口输出调试信息}

CONNECT报文，连接服务器报文
10（报文类型）+65(有效长度)+00 04 4D 51 54(协议名)+04(协议级别)+C2(连接标志)+00 64(保活时间)+客户端+用户名+密码构成

/*----------------------------------------------------------*//*函数名：连接服务器报文       1                            *//*参  数：无                                                *//*返回值：无                                                *//*----------------------------------------------------------*/void MQTT_ConectPack(void){        int temp,Remaining_len;Fixed_len = 1;                                                        //连接报文中，固定报头长度暂时先=1Variable_len = 10;                                                    //连接报文中，可变报头长度=10Payload_len = 2 + ClientID_len + 2 + Username_len + 2 + Passward_len; //连接报文中，负载长度      Remaining_len = Variable_len + Payload_len;                           //剩余长度=可变报头长度+负载长度temp_buff[0]=0x10;                       //固定报头第1个字节 ：固定0x10                do{                                      //循环处理固定报头中的剩余长度字节，字节量根据剩余字节的真实长度变化temp = Remaining_len%128;            //剩余长度取余128Remaining_len = Remaining_len/128;   //剩余长度取整128if(Remaining_len>0)                       temp |= 0x80;                    //按协议要求位7置位          temp_buff[Fixed_len] = temp;         //剩余长度字节记录一个数据Fixed_len++;                             //固定报头总长度+1    }while(Remaining_len>0);                 //如果Remaining_len>0的话，再次进入循环temp_buff[Fixed_len+0]=0x00;  //可变报头第1个字节 ：固定0x00 两长度表示协议名            temp_buff[Fixed_len+1]=0x04;  //可变报头第2个字节 ：固定0x04 4字节temp_buff[Fixed_len+2]=0x4D;        //可变报头第3个字节 ：固定0x4D Mtemp_buff[Fixed_len+3]=0x51;        //可变报头第4个字节 ：固定0x51 Qtemp_buff[Fixed_len+4]=0x54;        //可变报头第5个字节 ：固定0x54 Ttemp_buff[Fixed_len+5]=0x54;        //可变报头第6个字节 ：固定0x54 Ttemp_buff[Fixed_len+6]=0x04;        //可变报头第7个字节 ：固定0x04 协议级别 4temp_buff[Fixed_len+7]=0xC2;        //可变报头第8个字节 ：使能用户名和密码校验，不使用遗嘱，不保留会话temp_buff[Fixed_len+8]=0x00;         //可变报头第9个字节 ：保活时间高字节 0x00temp_buff[Fixed_len+9]=0x64;        //可变报头第10个字节：保活时间高字节 0x64   100s/*     CLIENT_ID      */temp_buff[Fixed_len+10] = ClientID_len/256;                                                                      //客户端ID长度高字节temp_buff[Fixed_len+11] = ClientID_len%256;                                                                     //客户端ID长度低字节memcpy(&temp_buff[Fixed_len+12],ClientID,ClientID_len);                                         //复制过来客户端ID字串        /*     用户名        */temp_buff[Fixed_len+12+ClientID_len] = Username_len/256;                                                       //用户名长度高字节temp_buff[Fixed_len+13+ClientID_len] = Username_len%256;                                                      //用户名长度低字节memcpy(&temp_buff[Fixed_len+14+ClientID_len],Username,Username_len);                //复制过来用户名字串        /*      密码        */temp_buff[Fixed_len+14+ClientID_len+Username_len] = Passward_len/256;                            //密码长度高字节temp_buff[Fixed_len+15+ClientID_len+Username_len] = Passward_len%256;                            //密码长度低字节memcpy(&temp_buff[Fixed_len+16+ClientID_len+Username_len],Passward,Passward_len);   //复制过来密码字串u2_printf("发送报文：%s\r\n",temp_buff);               //串口输出调试信息TxDataBuf_Deal(temp_buff, Fixed_len + Variable_len + Payload_len);                  //加入发送数据缓冲区}

SUBSCRIBE订阅报文（等级0）
SUBSCRIBE构成为 82(固定报头)+00 01(可变标识符)+有效载荷(属性设置)+00(服务等级)

/*----------------------------------------------------------*//*函数名：SUBSCRIBE订阅topic报文                            *//*参  数：QoS：订阅等级                                     *//*参  数：topic_name：订阅topic报文名称                     *//*返回值：无                                                *//*----------------------------------------------------------*/void MQTT_Subscribe(char *topic_name, int QoS) {        Fixed_len = 2;                              //SUBSCRIBE报文中，固定报头长度=2Variable_len = 2;                           //SUBSCRIBE报文中，可变报头长度=2        Payload_len = 2 + strlen(topic_name) + 1;   //计算有效负荷长度 = 2字节(topic_name长度)+ topic_name字符串的长度 + 1字节服务等级temp_buff[0]=0x82;                                    //第1个字节 ：固定0x82                      temp_buff[1]=Variable_len + Payload_len;              //第2个字节 ：可变报头+有效负荷的长度        temp_buff[2]=0x00;                                    //第3个字节 ：报文标识符高字节，固定使用0x00temp_buff[3]=0x01;                                              //第4个字节 ：报文标识符低字节，固定使用0x01temp_buff[4]=strlen(topic_name)/256;                  //第5个字节 ：topic_name长度高字节temp_buff[5]=strlen(topic_name)%256;                          //第6个字节 ：topic_name长度低字节memcpy(&temp_buff[6],topic_name,strlen(topic_name));  //第7个字节开始 ：复制过来topic_name字串                temp_buff[6+strlen(topic_name)]=QoS;                  //最后1个字节：订阅等级u2_printf("发送报文0：%s\r\n",temp_buff);               //串口输出调试信息TxDataBuf_Deal(temp_buff, Fixed_len + Variable_len + Payload_len);  //加入发送数据缓冲区}

Publish报文，等级0

/*----------------------------------------------------------*//*函数名：等级0 发布消息报文           3                    *//*参  数：topic_name：topic名称                             *//*参  数：data：数据                                        *//*参  数：data_len：数据长度                                *//*返回值：无                                                *//*----------------------------------------------------------*/void MQTT_PublishQs0(char *topic, char *data, int data_len){        int temp,Remaining_len;Fixed_len = 1;                              //固定报头长度暂时先等于：1字节Variable_len = 2 + strlen(topic);           //可变报头长度：2字节(topic长度)+ topic字符串的长度Payload_len = data_len;                     //有效负荷长度：就是data_lenRemaining_len = Variable_len + Payload_len; //剩余长度=可变报头长度+负载长度temp_buff[0]=0x30;                       //固定报头第1个字节 ：固定0x30           do{                                      //循环处理固定报头中的剩余长度字节，字节量根据剩余字节的真实长度变化temp = Remaining_len%128;            //剩余长度取余128Remaining_len = Remaining_len/128;   //剩余长度取整128if(Remaining_len>0)                       temp |= 0x80;                    //按协议要求位7置位          temp_buff[Fixed_len] = temp;         //剩余长度字节记录一个数据Fixed_len++;                             //固定报头总长度+1    }while(Remaining_len>0);                 //如果Remaining_len>0的话，再次进入循环temp_buff[Fixed_len+0]=strlen(topic)/256;                      //可变报头第1个字节     ：topic长度高字节temp_buff[Fixed_len+1]=strlen(topic)%256;                                               //可变报头第2个字节     ：topic长度低字节memcpy(&temp_buff[Fixed_len+2],topic,strlen(topic));           //可变报头第3个字节开始 ：拷贝topic字符串        memcpy(&temp_buff[Fixed_len+2+strlen(topic)],data,data_len);   //有效负荷：拷贝data数据TxDataBuf_Deal(temp_buff, Fixed_len + Variable_len + Payload_len);  //加入发送数据缓冲区}

处理Publish报文返回的数据，并从数据中提取关键命令拷贝到命令数组。

/*----------------------------------------------------------*//*函数名：处理服务器发来的等级0的推送                       *//*参  数：redata：接收的数据                                *//*返回值：无                                                *//*----------------------------------------------------------*/void MQTT_DealPushdata_Qs0(unsigned char *redata){int  re_len;                                  //定义一个变量，存放接收的数据总长度int  pack_num;                         //定义一个变量，当多个推送一起过来时，保存推送的个数int  temp,temp_len;                    //定义一个变量，暂存数据int  totle_len;                        //定义一个变量，存放已经统计的推送的总数据量int  topic_len;                                      //定义一个变量，存放推送中主题的长度int  cmd_len;                          //定义一个变量，存放推送中包含的命令数据的长度int  cmd_loca;                         //定义一个变量，存放推送中包含的命令的起始位置int  i;                                //定义一个变量，用于for循环int  local,multiplier;unsigned char tempbuff[BUFF_UNIT];           //临时缓冲区unsigned char *data;                   //redata过来的时候，第一个字节是数据总量，data用于指向redata的第2个字节，真正的数据开始的地方re_len = redata[0]*256+redata[1];                               //获取接收的数据总长度                data = &redata[2];                                              //data指向redata的第2个字节，真正的数据开始的 pack_num = temp_len = totle_len = temp = 0;                            //各个变量清零local = 1;multiplier = 1;do{pack_num++;                                                             //开始循环统计推送的个数，每次循环推送的个数+1        do{temp = data[totle_len + local];   temp_len += (temp & 127) * multiplier;multiplier *= 128;local++;}while ((temp & 128) != 0);totle_len += (temp_len + local);                                  //累计统计的总的推送的数据长度re_len -= (temp_len + local) ;                              //接收的数据总长度 减去 本次统计的推送的总长度      local = 1;multiplier = 1;temp_len = 0;}while(re_len!=0);                                                          //如果接收的数据总长度等于0了，说明统计完毕了u2_printf("本次接收了%d个推送数据\r\n",pack_num);//串口输出信息temp_len = totle_len = 0;                                                    //各个变量清零local = 1;multiplier = 1;for(i=0;i

/*----------------------------------------------------------*//*函数名：PING报文，心跳包                                  *//*参  数：无                                                *//*返回值：无                                                *//*----------------------------------------------------------*/void MQTT_PingREQ(void){temp_buff[0]=0xC0;              //第1个字节 ：固定0xC0                      temp_buff[1]=0x00;              //第2个字节 ：固定0x00 TxDataBuf_Deal(temp_buff, 2);   //加入数据到缓冲区}

/*----------------------------------------------------------*//*函数名：处理发送缓冲区                                    *//*参  数：data：数据                                        *//*参  数：size：数据长度                                    *//*返回值：无                                                *//*----------------------------------------------------------*/void TxDataBuf_Deal(unsigned char *data, int size){memcpy(&MQTT_TxDataInPtr[2],data,size);      //拷贝数据到发送缓冲区        MQTT_TxDataInPtr[0] = size/256;              //记录数据长度MQTT_TxDataInPtr[1] = size%256;              //记录数据长度MQTT_TxDataInPtr+=BUFF_UNIT;                 //指针下移  a+=b  等同于a=a+b if(MQTT_TxDataInPtr==MQTT_TxDataEndPtr)      //如果指针到缓冲区尾部了MQTT_TxDataInPtr = MQTT_TxDataBuf[0];    //指针归位到缓冲区开头}

/*----------------------------------------------------------*//*函数名：处理命令缓冲区                                    *//*参  数：data：数据                                        *//*参  数：size：数据长度                                    *//*返回值：无                                                *//*----------------------------------------------------------*/void CMDBuf_Deal(unsigned char *data, int size){memcpy(&MQTT_CMDInPtr[2],data,size);      //拷贝数据到命令缓冲区MQTT_CMDInPtr[0] = size/256;              //记录数据长度MQTT_CMDInPtr[1] = size%256;              //记录数据长度MQTT_CMDInPtr[size+2] = '\0';             //加入字符串结束符MQTT_CMDInPtr+=BUFF_UNIT;                 //指针下移if(MQTT_CMDInPtr==MQTT_CMDEndPtr)         //如果指针到缓冲区尾部了MQTT_CMDInPtr = MQTT_CMDBuf[0];       //指针归位到缓冲区开头}

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！