stm32通过esp8266连接阿里云平台代码讲解

连接服务器

首先，按照一定的规则，获取连接阿里服务器所需要的ClientID（客户端D）、Username（用户名）、Passward(密码)，ServerIP（域名），ServerPort（端口号）

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

开始连接服务器

/*-------------------------------------------------*/
/*函数名：WiFi连接服务器                           */
/*参  数：无                                       */
/*返回值：0：正确   其他：错误                     */
/*-------------------------------------------------*/
char WiFi_Connect_IoTServer(void)
{	u1_printf("准备复位模块\r\n");                     //串口提示数据if(WiFi_Reset(50)){                                //复位，100ms超时单位，总计5s超时时间u1_printf("复位失败，准备重启\r\n");           //返回非0值，进入if，串口提示数据return 1;                                      //返回1}else u1_printf("复位成功\r\n");                   //串口提示数据u1_printf("准备设置STA模式\r\n");                  //串口提示数据if(WiFi_SendCmd("AT+CWMODE=1",50)){                //设置STA模式，100ms超时单位，总计5s超时时间u1_printf("设置STA模式失败，准备重启\r\n");    //返回非0值，进入if，串口提示数据return 2;                                      //返回2}else u1_printf("设置STA模式成功\r\n");            //串口提示数据if(wifi_mode==0){                                      //如果联网模式=0：SSID和密码写在程序里 u1_printf("准备取消自动连接\r\n");                 //串口提示数据if(WiFi_SendCmd("AT+CWAUTOCONN=0",50)){            //取消自动连接，100ms超时单位，总计5s超时时间u1_printf("取消自动连接失败，准备重启\r\n");   //返回非0值，进入if，串口提示数据return 3;                                      //返回3}else u1_printf("取消自动连接成功\r\n");           //串口提示数据u1_printf("准备连接路由器\r\n");                   //串口提示数据	if(WiFi_JoinAP(30)){                               //连接路由器,1s超时单位，总计30s超时时间u1_printf("连接路由器失败，准备重启\r\n");     //返回非0值，进入if，串口提示数据return 4;                                      //返回4	}else u1_printf("连接路由器成功\r\n");             //串口提示数据			}
#if (debug == 0)	else{                                                 //如果联网模式=1：Smartconfig方式,用APP发送if(KEY2_IN_STA==0){                                    //如果此时K2是按下的u1_printf("准备设置自动连接\r\n");                 //串口提示数据if(WiFi_SendCmd("AT+CWAUTOCONN=1",50)){            //设置自动连接，100ms超时单位，总计5s超时时间u1_printf("设置自动连接失败，准备重启\r\n");   //返回非0值，进入if，串口提示数据return 3;                                      //返回3}else u1_printf("设置自动连接成功\r\n");           //串口提示数据	u1_printf("准备开启Smartconfig\r\n");              //串口提示数据if(WiFi_SendCmd("AT+CWSTARTSMART",50)){            //开启Smartconfig，100ms超时单位，总计5s超时时间u1_printf("开启Smartconfig失败，准备重启\r\n");//返回非0值，进入if，串口提示数据return 4;                                      //返回4}else u1_printf("开启Smartconfig成功\r\n");        //串口提示数据u1_printf("请使用APP软件传输密码\r\n");            //串口提示数据if(WiFi_Smartconfig(60)){                          //APP软件传输密码，1s超时单位，总计60s超时时间u1_printf("传输密码失败，准备重启\r\n");       //返回非0值，进入if，串口提示数据return 5;                                      //返回5}else u1_printf("传输密码成功\r\n");               //串口提示数据u1_printf("准备关闭Smartconfig\r\n");              //串口提示数据if(WiFi_SendCmd("AT+CWSTOPSMART",50)){             //关闭Smartconfig，100ms超时单位，总计5s超时时间u1_printf("关闭Smartconfig失败，准备重启\r\n");//返回非0值，进入if，串口提示数据return 6;                                      //返回6}else u1_printf("关闭Smartconfig成功\r\n");        //串口提示数据}else{                                                 //反之，此时K2是没有按下u1_printf("等待连接路由器\r\n");                   //串口提示数据	if(WiFi_WaitAP(30)){                               //等待连接路由器,1s超时单位，总计30s超时时间u1_printf("连接路由器失败，准备重启\r\n");     //返回非0值，进入if，串口提示数据return 7;                                      //返回7	}else u1_printf("连接路由器成功\r\n");             //串口提示数据					}}
#endifu1_printf("准备设置透传\r\n");                     //串口提示数据if(WiFi_SendCmd("AT+CIPMODE=1",50)){               //设置透传，100ms超时单位，总计5s超时时间u1_printf("设置透传失败，准备重启\r\n");       //返回非0值，进入if，串口提示数据return 8;                                      //返回8}else u1_printf("设置透传成功\r\n");               //串口提示数据u1_printf("准备关闭多路连接\r\n");                 //串口提示数据if(WiFi_SendCmd("AT+CIPMUX=0",50)){                //关闭多路连接，100ms超时单位，总计5s超时时间u1_printf("关闭多路连接失败，准备重启\r\n");   //返回非0值，进入if，串口提示数据return 9;                                      //返回9}else u1_printf("关闭多路连接成功\r\n");           //串口提示数据u1_printf("准备连接服务器\r\n");                   //串口提示数据if(WiFi_Connect_Server(100)){                      //连接服务器，100ms超时单位，总计10s超时时间u1_printf("连接服务器失败，准备重启\r\n");     //返回非0值，进入if，串口提示数据return 10;                                     //返回10}else u1_printf("连接服务器成功\r\n");             //串口提示数据	return 0;                                          //正确返回0}

/*-------------------------------------------------*/
/*函数名：连接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;                               //已经建立连接返回2u1_printf("%d ",timeout);                   //串口输出现在的超时时间  }u1_printf("\r\n");                        //串口输出信息if(timeout<=0)return 3;                   //超时错误，返回3else                                      //连接成功，准备进入透传{u1_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循环u1_printf("%d ",timeout);           //串口输出现在的超时时间  }if(timeout<=0)return 4;                 //透传超时错误，返回4	}return 0;	                                //成功返回0	
}

上面的代码就实现了esp8266连接上了阿里云TCP服务器，并且进入透传模式。

接着我们开始发送连接服务器报文CONNECT了，

CONNECT格式为：固定报头+可变报头+有效载荷
固定报头：0x10+剩余长度（可变报头+有效载荷的长度），如果剩余长度大于128，那么要用两个字节表示（剩余%128 | 0x80 ， 以及剩余长度 / 128）。如果剩余长度小于128，那么用一个字节表示（剩余长度）
可变报头：一共10个字节，前7个固定为字节（00 04 4D 51 54 54 04），第8、第9第10都有各自的意义，不做详细讲述
有效载荷：2个字节的ClientID长度+ClientID+两个字节的Username长度+Username+两个字节的Passward长度+Passward

代码如下

/*----------------------------------------------------------*/
/*函数名：连接服务器报文                                    */
/*参  数：无                                                */
/*返回值：无                                                */
/*----------------------------------------------------------*/
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个字节 ：固定0x01		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个字节 ：固定0x04temp_buff[Fixed_len+2]=0x4D;	//可变报头第3个字节 ：固定0x4Dtemp_buff[Fixed_len+3]=0x51;	//可变报头第4个字节 ：固定0x51temp_buff[Fixed_len+4]=0x54;	//可变报头第5个字节 ：固定0x54temp_buff[Fixed_len+5]=0x54;	//可变报头第6个字节 ：固定0x54temp_buff[Fixed_len+6]=0x04;	//可变报头第7个字节 ：固定0x04temp_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);   //复制过来密码字串TxDataBuf_Deal(temp_buff, Fixed_len + Variable_len + Payload_len);                  //加入发送数据缓冲区
}

可以看到这个函数将CONNECT报文按照规则填充好，然后发送到数据缓冲区内，等待发送CONNECT报文。

订阅主题

订阅报文SUBSCRIBE
SUBSCRIBE：固定报头 +可变报头+主题长度+主题+服务质量等级

固定报头：0x82+剩余长度（可变报头+有效载荷的长度），如果剩余长度大于128，那么要用两个字节表示（剩余%128 | 0x80 ， 以及剩余长度 / 128）。如果剩余长度小于128，那么用一个字节表示（剩余长度）

可变报头：两个字节，用来表示几号报文。
主题长度：两个字节
主题：要订阅的主题
服务质量等级：1个字节。

/*----------------------------------------------------------*/
/*函数名：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个字节：订阅等级TxDataBuf_Deal(temp_buff, Fixed_len + Variable_len + Payload_len);  //加入发送数据缓冲区
}

可以看到这个函数将SUBSCRIBE报文按照规则填充好，然后发送到数据缓冲区内，等待发送SUBSCRIBE报文。

向阿里云平台发送数据

/*-------------------------------------------------*/
/*函数名：采集温湿度，并发布给服务器               */
/*参  数：无                                       */
/*返回值：无                                       */
/*-------------------------------------------------*/
void TempHumi_State(void)
{u8 tempdata,humidata;	char temp[256];  DHT11_Read_Data(&tempdata,&humidata);	//读取温湿度值	
//	AHT10_Data(&tempdata,&humidata);u1_printf("温度：%d  湿度：%d\r\n",tempdata,humidata);tempdata = 30;sprintf(temp,"{\"method\":\"thing.event.property.post\",\"id\":\"000000001\",\"params\":{\"CurrentTemperature\":%2d},\"version\":\"1.0.0\"}",tempdata);  //构建回复湿度温度数据MQTT_PublishQs0(P_TOPIC_NAME,temp,strlen(temp));   //添加数据，发布给服务器	
}/*----------------------------------------------------------*/
/*函数名：等级0 发布消息报文                                */
/*参  数：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);  //加入发送数据缓冲区
}

解析阿里云平台的p

ublish数据
服务器发送数据给客户端的数据格式
固定报头（0x30+剩余长度）+可变报头（主题长度+主题）+有效载荷（数据内容）

在main函数里循环的检测云平台发送的数据里，首字符是否是0x30,如果是说明它是云平台推送的publish数据。

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

看到如下代码，它将解析出来的有效载荷（数据内容）通过CMDBuf_Deal()函数加入命令到缓冲区。

/*----------------------------------------------------------*/
/*函数名：处理服务器发来的等级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了，说明统计完毕了u1_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;}	
}/*----------------------------------------------------------*/
/*函数名：处理命令缓冲区                                    */
/*参  数：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];       //指针归位到缓冲区开头
}

再在main函数，循环检测命令缓冲区是否有数据

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

因为接受到有效载荷（数据内容）是json格式的，我们可以用cJSON库，来处理数据。
cJSON的使用可以参考这篇文章：cJSON使用
处理过程过如下：

/*----------------------------------------------------------*/
/*函数名：解析JSON格式函数                                    */
/*参  message  :  待解析的JSON格式数据                        */              
/*返回值：无                                                */
/*----------------------------------------------------------*/
void receivedata_chuli(unsigned char * message) //阿里云推送数据json格式数据获取出来
{cJSON* cjson_test = NULL; //创建链表头指针：cJSON* cjson_params = NULL;cJSON* cjson_params_CurrentTemperature = NULL;cjson_test = cJSON_Parse((char *)message);// 解析整段JSON数据，并将链表头结点地址返回，赋值给头指针：cjson_params = cJSON_GetObjectItem(cjson_test, "params"); //根据键值对的名称从链表中取出对应的值，返回该键值对(链表节点)的地址cjson_params_CurrentTemperature = cJSON_GetObjectItem(cjson_params, "LightSwitch");//根据键值对的名称从链表中取出对应的值，返回该键值对(链表节点)的地址led_state = cjson_params_CurrentTemperature->valueint;if(led_state == 1) //接收到"LightSwitch"对应的键值为1{led_on();}else if(led_state == 0)//接收到"LightSwitch"对应的键值为0{led_off();}u1_printf("led_state :%d \r\n",led_state);cJSON_Delete(cjson_test);}

最终我们获取了云平台设置的标识符的对应键值。根据这个键值来确认是否开关灯。

实操效果

1.登陆云平台
2.进入对应设备的在线调试，可以看到，我这里建了两个物理模型，当前温度和主灯开关，它们的标识符分别为CurrentTemperature和LightSwitch。

3.设置对应的参数，然后点击设置按键，云平台即可发送数据给esp8266，esp8266再通过串口发送数据给stm32
stm32来解析这串字符串，并将里面的有效载荷（数据内容）获取出来，有效载荷（数据内容）里的内容是JSON格式的，所以用cJSON库做一个数据解析，根据标识符获取对应的键值，然后根据键值，判断是否开灯关灯。