一、MQTT
mqtt.h
#ifndef __MQTT_H
#define __MQTT_H
#define BUFF_UNIT 512 //缓冲区长度
#define R_NUM 8 //接收缓冲区个数
#define T_NUM 8 //发送缓冲区个数
#define C_NUM 8 //命令缓冲区个数
#define MQTT_TxData(x) u2_TxData(x) //串口2负责数据发送
//**根据自己的三要素修改
#define PRODUCTKEY "**********" //产品ID
#define PRODUCTKEY_LEN strlen(PRODUCTKEY) //产品ID长度
#define DEVICENAME "**********" //设备名
#define DEVICENAME_LEN strlen(DEVICENAME) //设备名长度
#define DEVICESECRE "**********" //设备秘钥
#define DEVICESECRE_LEN strlen(DEVICESECRE) //设备秘钥长度
#define S_TOPIC_NAME "/sys/**/**/thing/service/property/set" //需要订阅的主题
#define P_TOPIC_NAME "/sys/**/**/thing/event/property/post" //需要发布的主题
extern unsigned char MQTT_RxDataBuf[R_NUM][BUFF_UNIT]; //数据的接收缓冲区,所有服务器发来的数据，存放在该缓冲区,缓冲区第一个字节存放数据长度
extern unsigned char *MQTT_RxDataInPtr; //指向缓冲区存放数据的位置
extern unsigned char *MQTT_RxDataOutPtr; //指向缓冲区读取数据的位置
extern unsigned char *MQTT_RxDataEndPtr; //指向缓冲区结束的位置
extern unsigned char MQTT_TxDataBuf[T_NUM][BUFF_UNIT]; //数据的发送缓冲区,所有发往服务器的数据，存放在该缓冲区,缓冲区第一个字节存放数据长度
extern unsigned char *MQTT_TxDataInPtr; //指向缓冲区存放数据的位置
extern unsigned char *MQTT_TxDataOutPtr; //指向缓冲区读取数据的位置
extern unsigned char *MQTT_TxDataEndPtr; //指向缓冲区结束的位置
extern unsigned char MQTT_CMDBuf[C_NUM][BUFF_UNIT]; //命令数据的接收缓冲区
extern unsigned char *MQTT_CMDInPtr; //指向缓冲区存放数据的位置
extern unsigned char *MQTT_CMDOutPtr; //指向缓冲区读取数据的位置
extern unsigned char *MQTT_CMDEndPtr; //指向缓冲区结束的位置
extern char ClientID[128]; //存放客户端ID的缓冲区
extern int ClientID_len; //存放客户端ID的长度
extern char Username[128]; //存放用户名的缓冲区
extern int Username_len; //存放用户名的长度
extern char Passward[128]; //存放密码的缓冲区
extern int Passward_len; //存放密码的长度
extern char ServerIP[128]; //存放服务器IP或是域名
extern int ServerPort; //存放服务器的端口号
extern char Ping_flag; //ping报文状态 0：正常状态，等待计时时间到，发送Ping报文
//ping报文状态 1：Ping报文已发送，当收到 服务器回复报文的后 将1置为0
extern char Connect_flag; //同服务器连接状态 0：还没有连接服务器 1：连接上服务器了
extern char ReConnect_flag; //重连服务器状态 0：连接还存在 1：连接断开，重连
extern char ConnectPack_flag; //CONNECT报文状态 1：CONNECT报文成功
extern char SubcribePack_flag; //订阅报文状态 1：订阅报文成功
void MQTT_Buff_Init(void);
void MQTT_Buff_ReInit(void);
void AliIoT_Parameter_Init(void);
void MQTT_ConectPack(void);
void MQTT_Subscribe(char *, int);
void MQTT_PingREQ(void);
void MQTT_PublishQs0(char *, char *, int);
void MQTT_DealPushdata_Qs0(unsigned char *);
void TxDataBuf_Deal(unsigned char *, int);
void CMDBuf_Deal(unsigned char *, int);
#endif
mqtt.c
#include "stm32f10x.h"
#include "mqtt.h"
#include "string.h"
#include "stdio.h"
#include "usart1.h" //串口打印
#include "utils_hmac.h" //编解码
#include "wifi.h" //esp8266
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 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]; //临时缓冲区，构建报文用
char Ping_flag; //ping报文状态 0：正常状态，等待计时时间到，发送Ping报文
//ping报文状态 1：Ping报文已发送，当收到 服务器回复报文的后 将1置为0
char Connect_flag; //同服务器连接状态 0：还没有连接服务器 1：连接上服务器了
char ConnectPack_flag; //CONNECT报文状态 1：CONNECT报文成功
char SubcribePack_flag; //订阅报文状态 1：订阅报文成功
//初始化接收,发送,命令数据的 缓冲区 以及各状态参数
void MQTT_Buff_Init(void)
{
MQTT_RxDataInPtr=MQTT_RxDataBuf[0]; //指向发送缓冲区存放数据的指针归位
MQTT_RxDataOutPtr=MQTT_RxDataInPtr; //指向发送缓冲区读取数据的指针归位
MQTT_RxDataEndPtr=MQTT_RxDataBuf[R_NUM-1]; //指向发送缓冲区结束的指针归位
MQTT_TxDataInPtr=MQTT_TxDataBuf[0]; //指向发送缓冲区存放数据的指针归位
MQTT_TxDataOutPtr=MQTT_TxDataInPtr; //指向发送缓冲区读取数据的指针归位
MQTT_TxDataEndPtr=MQTT_TxDataBuf[T_NUM-1]; //指向发送缓冲区结束的指针归位
MQTT_CMDInPtr=MQTT_CMDBuf[0]; //指向命令缓冲区存放数据的指针归位
MQTT_CMDOutPtr=MQTT_CMDInPtr; //指向命令缓冲区读取数据的指针归位
MQTT_CMDEndPtr=MQTT_CMDBuf[C_NUM-1]; //指向命令缓冲区结束的指针归位
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,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); //串口输出调试信息
}
//连接服务器报文
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); //加入发送数据缓冲区
}
//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); //加入发送数据缓冲区
}
//PING报文，心跳包
void MQTT_PingREQ(void)
{
temp_buff[0]=0xC0; //第1个字节 ：固定0xC0
temp_buff[1]=0x00; //第2个字节 ：固定0x00
TxDataBuf_Deal(temp_buff, 2); //加入数据到缓冲区
}
//等级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); //加入发送数据缓冲区
}
//处理服务器发来的等级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 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; //指针下移
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]; //指针归位到缓冲区开头
}
编解码自己上网寻找
#include "utils_hmac.h"
#include "utils_md5.h"
#include "utils_sha1.h"
二、ESP8266
wifi.h
#ifndef __WIFI_H
#define __WIFI_H
#include "usart2.h" //收发串口
#define RESET_IO(x) GPIO_WriteBit(GPIOB, GPIO_Pin_2, (BitAction)x) //PB2控制WiFi的复位
#define WiFi_printf u2_printf //串口2控制 WiFi
#define WiFi_RxCounter Usart2_RxCounter //串口2控制 WiFi
#define WiFi_RX_BUF Usart2_RxBuff //串口2控制 WiFi
#define WiFi_RXBUFF_SIZE USART2_RXBUFF_SIZE //串口2控制 WiFi
#define SSID "***" //路由器SSID名称
#define PASS "***" //路由器密码
void WiFi_ResetIO_Init(void);
char WiFi_SendCmd(char *cmd, int timeout);
char WiFi_Reset(int timeout);
char WiFi_JoinAP(int timeout);
char WiFi_Connect_Server(int timeout);
char WiFi_Smartconfig(int timeout);
char WiFi_WaitAP(int timeout);
char WiFi_Connect_IoTServer(void);
#endif
wifi.c
#include "stm32f10x.h" //包含需要的头文件
#include "wifi.h" //包含需要的头文件
#include "iic.h" //包含需要的头文件
#include "24c02.h" //包含需要的头文件
#include "delay.h" //包含需要的头文件
#include "usart1.h" //包含需要的头文件
#include "mqtt.h" //包含需要的头文件
//复位
void WiFi_ResetIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure; //定义IO端口参数的结构体
RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB , ENABLE); //使能PB端口时钟
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2; //准备设置PB2
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //速率50Mhz
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; //推免输出方式
GPIO_Init(GPIOB, &GPIO_InitStructure); //设置PB2
RESET_IO(1); //复位IO拉高电平
}
/*-------------------------------------------------*/
/*函数名：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
}
/*-------------------------------------------------*/
/*函数名：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循环
u1_printf("%d ",timeout); //串口输出现在的超时时间
}
u1_printf("\r\n"); //串口输出信息
if(timeout<=0)return 1; //如果timeout<=0，说明超时时间到了，也没能收到ready，返回1
else return 0; //反之，表示正确，说明收到ready，通过break主动跳出while
}
/*-------------------------------------------------*/
/*函数名：WiFi加入路由器指令 */
/*参 数：timeout：超时时间（1s的倍数） */
/*返回值：0：正确 其他：错误 */
/*-------------------------------------------------*/
char WiFi_JoinAP(int timeout)
{
WiFi_RxCounter=0; //WiFi接收数据量变量清零
memset(WiFi_RX_BUF,0,WiFi_RXBUFF_SIZE); //清空WiFi接收缓冲区
WiFi_printf("AT+CWJAP=\"%s\",\"%s\"\r\n",SSID,PASS); //发送指令
while(timeout--){ //等待超时时间到0
delay_ms(1000); //延时1s
if(strstr(WiFi_RX_BUF,"WIFI GOT IP\r\n\r\nOK")) //如果接收到WIFI GOT IP表示成功
break; //主动跳出while循环
u1_printf("%d ",timeout); //串口输出现在的超时时间
}
u1_printf("\r\n"); //串口输出信息
if(timeout<=0)return 1; //如果timeout<=0，说明超时时间到了，也没能收到WIFI GOT IP，返回1
else 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
}
/*-------------------------------------------------*/
/*函数名：等待加入路由器 */
/*参 数：timeout：超时时间（1s的倍数） */
/*返回值：0：正确 其他：错误 */
/*-------------------------------------------------*/
char WiFi_WaitAP(int timeout)
{
while(timeout--){ //等待超时时间到0
delay_ms(1000); //延时1s
if(strstr(WiFi_RX_BUF,"WIFI GOT IP")) //如果接收到WIFI GOT IP表示成功
break; //主动跳出while循环
u1_printf("%d ",timeout); //串口输出现在的超时时间
}
u1_printf("\r\n"); //串口输出信息
if(timeout<=0)return 1; //如果timeout<=0，说明超时时间到了，也没能收到WIFI GOT IP，返回1
return 0; //正确，返回0
}
/*-------------------------------------------------*/
/*函数名：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"); //串口提示数据
u1_printf("准备连接路由器\r\n"); //串口提示数据
if(WiFi_JoinAP(30)){ //连接路由器,1s超时单位，总计30s超时时间
u1_printf("连接路由器失败，准备重启\r\n"); //返回非0值，进入if，串口提示数据
return 4; //返回4
}else u1_printf("连接路由器成功\r\n"); //串口提示数据
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_Connect_Server(100)){ //连接服务器，100ms超时单位，总计10s超时时间
u1_printf("连接服务器失败，准备重启\r\n"); //返回非0值，进入if，串口提示数据
return 10; //返回10
}else u1_printf("连接服务器成功\r\n"); //串口提示数据
return 0; //正确返回0
}
三、用于ESP8266收发的串口
usart2.h
#ifndef __USART2_H
#define __USART2_H
#include "stdio.h" //包含需要的头文件
#include "stdarg.h" //包含需要的头文件
#include "string.h" //包含需要的头文件
#define USART2_RX_ENABLE 1 //是否开启接收功能 1：开启 0：关闭
#define USART2_TXBUFF_SIZE 1024 //定义串口2 发送缓冲区大小 1024字节
#if USART2_RX_ENABLE //如果使能接收功能
#define USART2_RXBUFF_SIZE 1024 //接收缓冲区大小 1024字节
extern char Usart2_RxCompleted ; //其他文件可以调用该变量
extern unsigned int Usart2_RxCounter; //其他文件可以调用该变量
extern char Usart2_RxBuff[USART2_RXBUFF_SIZE]; //其他文件可以调用该变量
#endif
void Usart2_Init(unsigned int);
void u2_printf(char*,...) ;
void u2_TxData(unsigned char *data);
#endif
usart2.c
#include "stm32f10x.h" //包含需要的头文件
#include "usart2.h" //包含需要的头文件
#if USART2_RX_ENABLE //如果使能接收功能
char Usart2_RxCompleted = 0; //定义一个变量 0：表示接收未完成 1：表示接收完成
unsigned int Usart2_RxCounter = 0; //定义一个变量，记录串口2总共接收了多少字节的数据
char Usart2_RxBuff[USART2_RXBUFF_SIZE]; //定义一个数组，用于保存串口2接收到的数据
#endif
/*-------------------------------------------------*/
/*函数名：初始化串口2发送功能 */
/*参 数：bound：波特率 */
/*返回值：无 */
/*-------------------------------------------------*/
void Usart2_Init(unsigned int bound)
{
GPIO_InitTypeDef GPIO_InitStructure; //定义一个设置GPIO功能的变量
USART_InitTypeDef USART_InitStructure; //定义一个设置串口功能的变量
#if USART2_RX_ENABLE //如果使能接收功能
NVIC_InitTypeDef NVIC_InitStructure; //如果使能接收功能，定义一个设置中断的变量
#endif
#if USART2_RX_ENABLE //如果使能接收功能
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置中断向量分组：第2组 抢先优先级：0 1 2 3 子优先级：0 1 2 3
#endif
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE); //使能串口2时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE); //使能GPIOA时钟
USART_DeInit(USART2); //串口2寄存器重新设置为默认值
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2; //准备设置PA2
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //IO速率50M
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出，用于串口2的发送
GPIO_Init(GPIOA, &GPIO_InitStructure); //设置PA2
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3; //准备设置PA3
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; //浮空输入，用于串口2的接收
GPIO_Init(GPIOA, &GPIO_InitStructure); //设置PA3
USART_InitStructure.USART_BaudRate = bound; //波特率设置
USART_InitStructure.USART_WordLength = USART_WordLength_8b; //8个数据位
USART_InitStructure.USART_StopBits = USART_StopBits_1; //1个停止位
USART_InitStructure.USART_Parity = USART_Parity_No; //无奇偶校验位
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
#if USART2_RX_ENABLE //如果使能接收模式
USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx; //收发模式
#else //如果不使能接收模式
USART_InitStructure.USART_Mode = USART_Mode_Tx ; //只发模式
#endif
USART_Init(USART2, &USART_InitStructure); //设置串口2
#if USART2_RX_ENABLE //如果使能接收模式
USART_ClearFlag(USART2, USART_FLAG_RXNE); //清除接收标志位
USART_ITConfig(USART2, USART_IT_RXNE, ENABLE); //开启接收中断
NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn; //设置串口2中断
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0; //抢占优先级0
NVIC_InitStructure.NVIC_IRQChannelSubPriority =0; //子优先级0
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //中断通道使能
NVIC_Init(&NVIC_InitStructure); //设置串口2中断
#endif
USART_Cmd(USART2, ENABLE); //使能串口2
}
/*-------------------------------------------------*/
/*函数名：串口2 printf函数 */
/*参 数：char* fmt,... 格式化输出字符串和参数 */
/*返回值：无 */
/*-------------------------------------------------*/
__align(8) char USART2_TxBuff[USART2_TXBUFF_SIZE];
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发送缓冲区中的数据 */
/*参 数：data：数据 */
/*返回值：无 */
/*-------------------------------------------------*/
void u2_TxData(unsigned char *data)
{
int i;
while((USART2->SR&0X40)==0);
for(i = 1;i <= (data[0]*256+data[1]);i ++){
USART2->DR = data[i+1];
while((USART2->SR&0X40)==0);
}
}
3298
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
