- delay_init(); //延时函数初始化
- LED_Init(); //初始化与LED连接的硬件接口
- uart1_init(115200);
- uart2_init(115200);
- TIM4_Init(300,7200); //TIM4初始化，定时时间 300*7200*1000/72000000 = 30ms
- LED_Init(); //LED初始化
- WiFi_ResetIO_Init();//ESP8266复位
- MQTT_Buff_Init(); //初始化接收,发送,命令数据的 缓冲区 以及各状态参数
- AliIoT_Parameter_Init();//阿里云初始化参数
然后判断发送数组的存放指针和读取是否相等，如果不相等，则数组中有数据等待发送。
最后发送数据并将指针下移。
- /*--------------------------------------------------------------------*/
- /* 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分支结尾
-
- /*-----------------------------------------------------*/
- /* 处理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 0x03
- case 0x04 : u2_printf("连接已拒绝，无效的用户名或密码，准备重启\r\n"); //串口输出信息
- Connect_flag = 0; //Connect_flag置零，重启连接
- break; //跳出分支case 0x04
- case 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的时间
- }
- }
- //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同服务器断开了连接,我们要重启连接服务器 */
- /*--------------------------------------------------------------------*/
- 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，表示正确，进入if
- u2_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.9
- GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
- GPIO_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;//PA10
- GPIO_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_RX
- USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //收发模式
- #else
- USART_InitStructure.USART_Mode = USART_Mode_Tx ; //只发模式
- #endif
- USART_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 ;//抢占优先级0
- NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //子优先级0
- NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能
- NVIC_Init(&NVIC_InitStructure); //根据指定的参数初始化VIC寄存器
- #endif
- USART_Cmd(USART1, ENABLE); //使能串口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);
- }
- }
- 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.9
- GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2; //PA.2
- GPIO_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;//PA3
- GPIO_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_RX
- USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //收发模式
- #else
- USART_InitStructure.USART_Mode = USART_Mode_Tx ; //只发模式
- #endif
- USART_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 ;//抢占优先级3
- NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1; //子优先级3
- NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能
- NVIC_Init(&NVIC_InitStructure); //根据指定的参数初始化VIC寄存器
- #endif
-
- USART_Cmd(USART2, ENABLE); //使能串口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);
- }
- }
配置定时器 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中断服务函数 */
- /*参 数：无 */
- /*返回值：无 */
- /*-------------------------------------------------*/
- 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中断服务函数 */
- /*参 数：无 */
- /*返回值：无 */
- /*-------------------------------------------------*/
- 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溢出中断标志
- }
- }
通过串口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; //准备设置PC13
- GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //速率50Mhz
- GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; //推免输出方式
- GPIO_Init(GPIOC, &GPIO_InitStructure); //设置PC13
-
- RESET_IO=1; //复位IO拉高电平
- }
- /*-------------------------------------------------*/
- /*函数名：WiFi复位 */
- /*参 数：timeout：超时时间（100ms的倍数） */
- /*返回值：0：正确 其他：错误 */
- /*-------------------------------------------------*/
- char WiFi_Reset(int timeout)
- {
- RESET_IO=0; //复位IO拉低电平
- delay_ms(500); //延时500ms
- RESET_IO=1; //复位IO拉高电平
- while(timeout--){ //等待超时时间到0
- delay_ms(100); //延时100ms
- if(strstr(WiFi_RX_BUF,"ready")) //如果接收到ready表示复位成功
- break; //主动跳出while循环
- u2_printf("%d ",timeout); //串口输出现在的超时时间
- }
- u2_printf("\r\n"); //串口输出信息
- if(timeout<=0)return 1; //如果timeout<=0，说明超时时间到了，也没能收到ready，返回1
- else return 0; //反之，表示正确，说明收到ready，通过break主动跳出while
- }
- /*-------------------------------------------------*/
- /*函数名：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--){ //等待超时时间到0
- delay_ms(100); //延时100ms
- if(strstr(WiFi_RX_BUF,"OK")) //如果接收到OK表示指令成功
- break; //主动跳出while循环
- u1_printf("%d ",timeout); //串口输出现在的超时时间
- }
- u1_printf("\r\n"); //串口输出信息
- if(timeout<=0)return 1; //如果timeout<=0，说明超时时间到了，也没能收到OK，返回1
- else return 0; //反之，表示正确，说明收到OK，通过break主动跳出while
- }
- /*-------------------------------------------------*/
- /*函数名：连接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; //服务器未开启返回1
- if(strstr(WiFi_RX_BUF ,"ALREADY CONNECTED"))//如果接受到ALREADY CONNECTED已经建立连接
- return 2; //已经建立连接返回2
- u2_printf("%d ",timeout); //串口输出现在的超时时间
- }
- u2_printf("\r\n"); //串口输出信息
- if(timeout<=0)return 3; //超时错误，返回3
- else //连接成功，准备进入透传
- {
- 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
- }
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
- }
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; //指向命令缓冲区结束的位置
- char Connect_flag; //同服务器连接状态 0：还没有连接服务器 1：连接上服务器了
- char Ping_flag; //ping报文状态 0：正常状态，等待计时时间到，发送Ping报文
- //ping报文状态 1：Ping报文已发送，当收到 服务器回复报文的后 将1置为0
- char ConnectPack_flag; //CONNECT报文状态 1：CONNECT报文成功
- char SubcribePack_flag; //订阅报文状态 1：订阅报文成功
- 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指针在缓冲区顶部，进入if
- MQTT_TxDataOutPtr =MQTT_TxDataBuf[T_NUM-4];//重定位OUT指针
- }else if(MQTT_TxDataOutPtr==MQTT_TxDataBuf[1]){//如果，现在OUT指针在缓冲区顶部下一个单元，进入if
- MQTT_TxDataOutPtr =MQTT_TxDataBuf[T_NUM-3];//重定位OUT指针
- }else if(MQTT_TxDataOutPtr==MQTT_TxDataBuf[2]){//如果，现在OUT指针在缓冲区顶部下两个单元，进入if
- MQTT_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; //各个参数清零
- }
- /*----------------------------------------------------------*/
- /*函数名：阿里云初始化参数，得到客户端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 i5drb0tO5li
- Passward_len = strlen(Passward); //计算用户名的长度
- memset(ServerIP,0,128);
- sprintf(ServerIP,"%s.iot-as-mqtt.cn-shanghai.aliyuncs.com",PRODUCTKEY); //构建服务器域名
- ServerPort = 1883; //服务器端口号1883
-
- u2_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); //串口输出调试信息
- }
10（报文类型）+65(有效长度)+00 04 4D 51 54(协议名)+04(协议级别)+C2(连接标志)+00 64(保活时间)+客户端+用户名+密码构成
- /*----------------------------------------------------------*/
- /*函数名：连接服务器报文 1 */
- /*参 数：无 */
- /*返回值：无 */
- /*----------------------------------------------------------*/
- void MQTT_ConectPack(void)
- {
- int temp,Remaining_len;
-
- Fixed_len = 1; //连接报文中，固定报头长度暂时先=1
- Variable_len = 10; //连接报文中，可变报头长度=10
- Payload_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; //剩余长度取余128
- Remaining_len = Remaining_len/128; //剩余长度取整128
- if(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 M
- temp_buff[Fixed_len+3]=0x51; //可变报头第4个字节 ：固定0x51 Q
- temp_buff[Fixed_len+4]=0x54; //可变报头第5个字节 ：固定0x54 T
- temp_buff[Fixed_len+5]=0x54; //可变报头第6个字节 ：固定0x54 T
- temp_buff[Fixed_len+6]=0x04; //可变报头第7个字节 ：固定0x04 协议级别 4
- temp_buff[Fixed_len+7]=0xC2; //可变报头第8个字节 ：使能用户名和密码校验，不使用遗嘱，不保留会话
- temp_buff[Fixed_len+8]=0x00; //可变报头第9个字节 ：保活时间高字节 0x00
- temp_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构成为 82(固定报头)+00 01(可变标识符)+有效载荷(属性设置)+00(服务等级)
- /*----------------------------------------------------------*/
- /*函数名：SUBSCRIBE订阅topic报文 */
- /*参 数：QoS：订阅等级 */
- /*参 数：topic_name：订阅topic报文名称 */
- /*返回值：无 */
- /*----------------------------------------------------------*/
- void MQTT_Subscribe(char *topic_name, int QoS)
- {
- Fixed_len = 2; //SUBSCRIBE报文中，固定报头长度=2
- Variable_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个字节 ：报文标识符高字节，固定使用0x00
- temp_buff[3]=0x01; //第4个字节 ：报文标识符低字节，固定使用0x01
- temp_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); //加入发送数据缓冲区
- }
- /*----------------------------------------------------------*/
- /*函数名：等级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_len
- Remaining_len = Variable_len + Payload_len; //剩余长度=可变报头长度+负载长度
-
- temp_buff[0]=0x30; //固定报头第1个字节 ：固定0x30
- do{ //循环处理固定报头中的剩余长度字节，字节量根据剩余字节的真实长度变化
- temp = Remaining_len%128; //剩余长度取余128
- Remaining_len = Remaining_len/128; //剩余长度取整128
- if(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<pack_num;i++){ //已经统计到了接收的推送个数，开始for循环，取出每个推送的数据
- do{
- temp = data[totle_len + local];
- temp_len += (temp & 127) * multiplier;
- multiplier *= 128;
- local++;
- }while ((temp & 128) != 0);
- topic_len = data[local+totle_len]*256+data[local+1+totle_len] + 2; //计算本次推送数据中主题占用的数据量
- cmd_len = temp_len-topic_len; //计算本次推送数据中命令数据占用的数据量
- cmd_loca = totle_len + local + topic_len; //计算本次推送数据中命令数据开始的位置
- memcpy(tempbuff,&data[cmd_loca],cmd_len); //命令数据拷贝出来
- CMDBuf_Deal(tempbuff, cmd_len); //加入命令到缓冲区
- totle_len += (temp_len+local); //累计已经统计的推送的数据长度
- local = 1;
- multiplier = 1;
- temp_len = 0;
- }
- }
PING心跳包报文
- /*----------------------------------------------------------*/
- /*函数名：PING报文，心跳包 */
- /*参 数：无 */
- /*返回值：无 */
- /*----------------------------------------------------------*/
- void MQTT_PingREQ(void)
- {
- temp_buff[0]=0xC0; //第1个字节 ：固定0xC0
- temp_buff[1]=0x00; //第2个字节 ：固定0x00
- TxDataBuf_Deal(temp_buff, 2); //加入数据到缓冲区
- }
处理缓冲区函数
操作指针，控制数组中的数据
接收缓冲区的处理函数在定时器4的中断函数中。
- /*----------------------------------------------------------*/
- /*函数名：处理发送缓冲区 */
- /*参 数：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]; //指针归位到缓冲区开头
- }
楼主
