连接服务器
首先，按照一定的规则，获取连接阿里服务器所需要的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; //服务器端口号1883
u1_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"); //串口提示数据
}
}
#endif
u1_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; //服务器未开启返回1
if(strstr(WiFi_RX_BUF ,"ALREADY CONNECTED"))//如果接受到ALREADY CONNECTED已经建立连接
return 2; //已经建立连接返回2
u1_printf("%d ",timeout); //串口输出现在的超时时间
}
u1_printf("\r\n"); //串口输出信息
if(timeout<=0)return 3; //超时错误，返回3
else //连接成功，准备进入透传
{
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; //连接报文中，固定报头长度暂时先=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个字节 ：固定0x01
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
temp_buff[Fixed_len+2]=0x4D; //可变报头第3个字节 ：固定0x4D
temp_buff[Fixed_len+3]=0x51; //可变报头第4个字节 ：固定0x51
temp_buff[Fixed_len+4]=0x54; //可变报头第5个字节 ：固定0x54
temp_buff[Fixed_len+5]=0x54; //可变报头第6个字节 ：固定0x54
temp_buff[Fixed_len+6]=0x04; //可变报头第7个字节 ：固定0x04
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); //复制过来密码字串
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报文中，固定报头长度=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个字节：订阅等级
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_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); //加入发送数据缓冲区
}
解析阿里云平台的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库做一个数据解析，根据标识符获取对应的键值，然后根据键值，判断是否开灯关灯。
1440
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
