1、硬件
2、资源
3、任务和步骤
4、效果
1、硬件
（1）stm32f4
(2)DAP下载器
（3）正点原子wifi模块，atk8266
软件资源，手机端下载一个网络调试助手，可以接受从机8266发过来的信息。
2、资源
atk8266-----------接stm32F4的串口2，PD5，PD6，其中PD5是TXD，PD6是RXD。
stm32F4的串口1，PA9和PA10，PA9—TXD，PA10–RXD 。
波特率设置115200
3。任务和步骤。
明确两个概念：（更加详细，看B站，搜索青柚物联网，的视频，有对应讲解。PDF和代码也有）
概念1：TCP协议。
TCP协议，是说A和B要进行通信对话，必须遵守的一个对话协议，就是对话的暗号格式。
包括了server服务器和client客户端。也叫主机和从机端。
要完成对话，必须IP地址要连接上，并且端口号也要一样。
比如主机A的IP地址是192.168.1.1，端口号是5000，
那么从机8266必须要连接到热点之后，连接到192.168.1.1，并且连接上5000的端口，才能进行对话。
ESP82668266和热点对话的几个串联开关。
k1:8266要进行初始化，主要是串口2的初始化，同时打开串口中断，在中断服务函数里面做解码；
K2-------------连接热点，connectAP.
K3-----------连接热点之后，设置TCP模式，连接IP地址和端口。
三个都通之后，才能进行wifi对话。
概念2：AP模式和STA模式。
AP模式是热点模式，P是point。点。
sta模式是从站模式，station.
一般比赛中，要求，接收外部热点wifi的命令，所以8266应该是客户端，连接到热点。
从之前的通知中，指导会给IP地址，端口号，wifi账号，和密码。所以推测试TCP的模式，而不是UDP模式。
步骤：
1、手机开热点，设置手机热点的账号，以及密码；
2、手机端下载网络调试助手，选择TCPserver模式，配置，到时候设置端口号，软件默认好像是5000，并且打开，打开端口的时候，可以知道手机当前的IP地址，这个IP地址，到时候要记下来；
3、修改stm32F4的network.h文件的对应内容，包括热点的名字，热点的密码，TCP的IP地址，写在stm32F4的network.h里面的对应宏定义的IP地址那里，改为需要的热点的IP地址，然后重新编译下载到stm32F4中，不然8266会连接不到热点服务器，进行不了TCP通信。。
使用TCP协议通信方式，手机热点是server服务端；8266连接手机热点，是从机，作为TCP的client客户端。
4、接线：
连接杜邦线。
（1）DAP下载线连接
（2）ESP8266和STM32F4接线
8266的VCC—3.3V
8266的GND—GND
8266的RXD—PD5（TXD，串口2）
8266的TXD—PD6（RXD，串口2）；
（3）USB转TTL模块（stm32f4的串口1用来将接收到的数据，解码之后，发送到电脑串口调试助手进行显示）
RXD----PA9
TXD----PA10
GND—GND，（用来接收信息）
5、编译程序，下载程序。
效果
手机端发送一串字符，比如123+321,8266接收到之后，解读代码，得到+号在字符串的位置，然后，将+的前三个字符复制到数组，后三个字符也复制到数组，将数组回传到串口调试助手，看下是不是正常。
（注：为什么这么做，要找到字符串的+号呢，因为比赛没说清楚，是发什么信息，是单单任务的信息，一直发？还是有帧头等，也不清楚，所以做了个+号检测的功能，再将+前后各三个字符存储起来，作为任务代码。）
6、解读程序
6.1network.h
#ifndef __NETWORK_H
#define __NETWORK_H
#include "sys.h"
#include "usart.h"
/*连接AP宏定义*/
//#define SSID "WIFI_SSID"//wifi账号
//#define PWD "WIFI_PWD"//wifi密码
#define SSID "H217"//wifi账号
#define PWD "1234567890"//wifi密码
/*连接服务器宏定义*/
#define TCP "TCP"
#define UDP "UDP"
#define IP "10.126.35.87"//主机wifi热点地址
#define PORT 5000
/*发送接收缓冲区长度宏定义*/
#define TXBUFFER_LEN 100
#define RXBUFFER_LEN 100
extern u8 TXBuffer[TXBUFFER_LEN]; //网络通信数据发送缓冲
extern u8 RXBuffer[RXBUFFER_LEN]; //网络通信数据接收缓冲
u8 checkESP8266(void);//检查8266
u8 initESP8266(void);//初始化8266
void restoreESP8266(void);//重新恢复初始设置8266
u8 connectAP(u8* ssid,u8* pwd);//连接热点
u8 connectServer(u8* mode,u8* ip,u16 port);//连接服务器，模式，IP地址，端口号
void sendBuffertoServer(u8* buffer);//将数据发送到服务器wifi端
void processServerBuffer(void);//将接收到的数据，进行解码
u8 disconnectServer(void);//断开和服务器的连接
#endif
6.2network.c
/******************************************************************
*******************************************************************/
#include "stdio.h"
#include "string.h"
#include "NetWork.h"
u8 TXBuffer[TXBUFFER_LEN] = {0}; //网络通信数据发送缓冲
u8 RXBuffer[RXBUFFER_LEN] = {0}; //网络通信数据接收缓冲
/**
* 功能：查找字符串中是否包含另一个字符串
* 参数：
* dest：待查找目标字符串
* src：待查找内容
* retry_cn:查询超时时间
* 返回值：查找结果，非0为查找成功,0为失败
* 说明：
* 当发出一个AT指令后，需要一段时间等待ESP8266回复,因此就需要等待一段时间,
* 这个时间通常是几百ms(除了连接服务器和AP指令),本程序一般指令通常等待
* 2S,耗时的连接AP和服务器的设置等待为8S,其实花不了那么多时间,但如果发生超时
* 就一定可以判断是通信问题
*/
static u8 findStr(u8* dest,u8* src,u16 retry_cn)
{
u16 retry = retry_cn; //超时时间
u8 result_flag = 0; //查找结果
while(strstr(dest,src)==0 && --retry!=0)//等待串口接收完毕或超时退出
{
delay_ms(10);
}
if(retry==0) //如果超时则有问题,此时返回0
{
return 0;
}
result_flag = 1; //执行到这里说明一切正常, 表示查找成功
if(result_flag)
{
return 1;
}else
{
return 0;
}
}
/**
* 功能：初始化ESP8266
* 参数：None
* 返回值：初始化结果，非0为初始化成功,0为失败
*/
u8 initESP8266(void)
{
// LCD_ShowStringAsc160(0,10,RED, WHITE,"init8266inY");
sendString(USART2,"+++"); //退出透传
// LCD_ShowStringAsc160(0,10,RED, WHITE,"init8266in0");
delay_ms(500);
sendString(USART2,"AT+RST\r\n"); //重启ESP8266
// LCD_ShowStringAsc160(0,10,RED, WHITE,"init8266in1");
delay_ms(500);
if(checkESP8266()==0) //使用AT指令检查ESP8266是否存在
{
return 0;
}
memset(RXBuffer,0,RXBUFFER_LEN); //清空接收缓冲
sendString(USART2,"ATE0\r\n"); //关闭回显
// LCD_ShowStringAsc160(0,10,RED, WHITE,"init8266in2");
if(findStr(RXBuffer,"OK",200)==0) //设置不成功
{
return 0;
}
return 1; //设置成功
}
/**
* 功能：恢复出厂设置
* 参数：None
* 返回值：None
* 说明:此时ESP8266中的用户设置将全部丢失回复成出厂状态
*/
void restoreESP8266(void)
{
sendString(USART2,"+++"); //退出透传
delay_ms(500);
sendString(USART2,"AT+RESTORE\r\n");//恢复出厂
NVIC_SystemReset(); //同时重启单片机
}
/**
* 功能：检查ESP8266是否正常
* 参数：None
* 返回值：ESP8266返回状态
* 非0 ESP8266正常
* 0 ESP8266有问题
*/
u8 checkESP8266(void)
{
memset(RXBuffer,0,RXBUFFER_LEN); //清空接收缓冲
sendString(USART2,"AT\r\n"); //发送AT握手指令
if(findStr(RXBuffer,"OK",200)!=0)//ESP8266正常
{
return 1;
}else //ESP8266不正常
{
return 0;
}
}
/**
* 功能：连接热点
* 参数：
* ssid:热点名
* pwd:热点密码
* 返回值：
* 连接结果,非0连接成功,0连接失败
* 说明：
* 失败的原因有以下几种(UART通信和ESP8266正常情况下)
* 1. WIFI名和密码不正确
* 2. 路由器连接设备太多,未能给ESP8266分配IP
*/
u8 connectAP(u8* ssid,u8* pwd)
{
memset(RXBuffer,0,RXBUFFER_LEN);
sendString(USART2,"AT+CWMODE?\r\n"); //查询此时WIFI工作模式
if(findStr(RXBuffer,"CWMODE:1",200)==0) //如果此时不是MODE1模式,即不是STATION模式
{
memset(RXBuffer,0,RXBUFFER_LEN);
sendString(USART2,"AT+CWMODE_CUR=1\r\n"); //设置为STATION模式
if(findStr(RXBuffer,"OK",200)==0)
{
return 0;
}
}
memset(TXBuffer,0,RXBUFFER_LEN); //清空发送缓冲
memset(RXBuffer,0,RXBUFFER_LEN); //清空接收缓冲
sprintf(TXBuffer,"AT+CWJAP_CUR=\"%s\",\"%s\"\r\n",ssid,pwd);//连接目标AP
sendString(USART2,TXBuffer);
if(findStr(RXBuffer,"OK",800)!=0) //连接成功且分配到IP
{
return 1;
}
}
/**
* 功能：使用指定协议(TCP/UDP)连接到服务器
* 参数：
* mode:协议类型 "TCP","UDP"
* ip:目标服务器IP
* port:目标是服务器端口号
* 返回值：
* 连接结果,非0连接成功,0连接失败
* 说明：
* 失败的原因有以下几种(UART通信和ESP8266正常情况下)
* 1. 远程服务器IP和端口号有误
* 2. 未连接AP
* 3. 服务器端禁止添加(一般不会发生)
*/
u8 connectServer(u8* mode,u8* ip,u16 port)
{
memset(RXBuffer,0,RXBUFFER_LEN);
memset(TXBuffer,0,RXBUFFER_LEN);
sendString(USART2,"+++"); //多次连接需退出透传
delay_ms(500);
/*格式化待发送AT指令*/
sprintf(TXBuffer,"AT+CIPSTART=\"%s\",\"%s\",%d\r\n",mode,ip,port);
sendString(USART2,TXBuffer);
if(findStr(RXBuffer,"CONNECT",800)!=0)
{
memset(RXBuffer,0,RXBUFFER_LEN);
sendString(USART2,"AT+CIPMODE=1\r\n"); //设置为透传模式
if(findStr(RXBuffer,"OK",200)!=0)
{
memset(RXBuffer,0,RXBUFFER_LEN);
sendString(USART2,"AT+CIPSEND\r\n");//开始处于透传发送状态
if(findStr(RXBuffer,">",200)!=0)
{
return 1;
}else
{
return 0;
}
}else
{
return 0;
}
}else
{
return 0;
}
}
/**
* 功能：主动和服务器断开连接
* 参数：None
* 返回值：
* 连接结果,非0断开成功,0断开失败
*/
u8 disconnectServer(void)
{
sendString(USART2,"+++"); //退出透传
delay_ms(500);
memset(RXBuffer,0,RXBUFFER_LEN);
sendString(USART2,"AT+CIPCLOSE\r\n");//关闭链接
if(findStr(RXBuffer,"CLOSED",200)!=0)//操作成功,和服务器成功断开
{
return 1;
}else
{
return 0;
}
}
/**
* 功能：透传模式下的数据发送函数
* 参数：
* buffer:待发送数据
* 返回值：None
*/
void sendBuffertoServer(u8* buffer)
{
memset(RXBuffer,0,RXBUFFER_LEN);
sendString(USART2,buffer);
}
/**
* 功能：处理服务器发回来的控制指令
* 参数：None
* 返回值：None
*/
void processServerBuffer(void)
{
u8 i = 0;
u8 numbuftemp0[9]={0};
unsigned long numtemp0=0;
/*若果接收到的数据有+号*/
if(strstr(RXBuffer,"+"))
{
memset(numbuftemp0,0,9);//将数组清0
numtemp0=FindNumInStr(RXBuffer);
delay_ms(5);
printf("+ in %d",numtemp0);//将+的位置打印出来；
//将+的位置前三位，作为数据，后三位作为数据，不知道帧头和帧尾。
//123+321
//2345
numbuftemp0[0]=RXBuffer[numtemp0-3];
numbuftemp0[1]=RXBuffer[numtemp0-2];
numbuftemp0[2]=RXBuffer[numtemp0-1];
numbuftemp0[3]=RXBuffer[numtemp0];
numbuftemp0[4]=RXBuffer[numtemp0+1];
numbuftemp0[5]=RXBuffer[numtemp0+2];
numbuftemp0[6]=RXBuffer[numtemp0+3];
printf("task =%s\r\n",numbuftemp0);//将+的前后123+321打印出来；
++i;//清空的标记
}
/*只在接收控制指令时才清空,这样可避免接收AT指令时导致失败*/
if(i!=0)
{
memset(RXBuffer,0,RXBUFFER_LEN);//将缓冲区清空
}
}
6.3uart.h
#ifndef __USART_H
#define __USART_H
#include "stdio.h"
#include "stm32f4xx_conf.h"
#include "sys.h"
//
//
#define USART_REC_LEN 200 //定义最大接收字节数 200
#define EN_USART1_RX 1 //使能（1）/禁止（0）串口1接收
extern u8 USART_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
extern u16 USART_RX_STA; //接收状态标记
//如果想串口中断接收，请不要注释以下宏定义
void uart_init(u32 bound);
void initUART2(u32 BaudRate);//串口2初始化
void sendByte(USART_TypeDef *USARTx, u16 byte);
void sendString(USART_TypeDef *USARTx, char *str);
#endif
6.4uart.c
#include "sys.h"
#include "usart.h"
#include <stdio.h>
#include "NetWork.h"
extern u8 RXBuffer[RXBUFFER_LEN];
//
//如果使用ucos,则包括下面的头文件即可.
#if SYSTEM_SUPPORT_OS
#include "includes.h" //ucos 使用
#endif
//
//本程序只供学习使用，未经作者许可，不得用于其它任何用途
//
//
//加入以下代码,支持printf函数,而不需要选择use MicroLIB
#if 1
#pragma import(__use_no_semihosting)
//标准库需要的支持函数
struct __FILE
{
int handle;
};
FILE __stdout;
//定义_sys_exit()以避免使用半主机模式
_sys_exit(int x)
{
x = x;
}
//重定义fputc函数
int fputc(int ch, FILE *f)
{
while((USART1->SR&0X40)==0);//循环发送,直到发送完毕
USART1->DR = (u8) ch;
return ch;
}
#endif
#if EN_USART1_RX //如果使能了接收
//串口1中断服务程序
//注意,读取USARTx->SR能避免莫名其妙的错误
u8 USART_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.
//接收状态
//bit15， 接收完成标志
//bit14， 接收到0x0d
//bit13~0， 接收到的有效字节数目
u16 USART_RX_STA=0; //接收状态标记
//初始化IO 串口1
//bound:波特率
void uart_init(u32 bound){
//GPIO端口设置
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE); //使能GPIOA时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);//使能USART1时钟
//串口1对应引脚复用映射
GPIO_PinAFConfig(GPIOA,GPIO_PinSource9,GPIO_AF_USART1); //GPIOA9复用为USART1
GPIO_PinAFConfig(GPIOA,GPIO_PinSource10,GPIO_AF_USART1); //GPIOA10复用为USART1
//USART1端口配置
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9 | GPIO_Pin_10; //GPIOA9与GPIOA10
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //速度50MHz
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽复用输出
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; //上拉
GPIO_Init(GPIOA,&GPIO_InitStructure); //初始化PA9，PA10
//USART1 初始化设置
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;//无硬件数据流控制
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //收发模式
USART_Init(USART1, &USART_InitStructure); //初始化串口1
USART_Cmd(USART1, ENABLE); //使能串口1
//USART_ClearFlag(USART1, USART_FLAG_TC);
#if EN_USART1_RX
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启相关中断
//Usart1 NVIC 配置
NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;//串口1中断通道
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3;//抢占优先级3
NVIC_InitStructure.NVIC_IRQChannelSubPriority =3; //子优先级3
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能
NVIC_Init(&NVIC_InitStructure); //根据指定的参数初始化VIC寄存器、
#endif
}
void USART1_IRQHandler(void) //串口1中断服务程序
{
u8 Res;
if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) //接收中断(接收到的数据必须是0x0d 0x0a结尾)
{
Res =USART_ReceiveData(USART1);//(USART1->DR); //读取接收到的数据
if((USART_RX_STA&0x8000)==0)//接收未完成
{
if(USART_RX_STA&0x4000)//接收到了0x0d
{
if(Res!=0x0a)USART_RX_STA=0;//接收错误,重新开始
else USART_RX_STA|=0x8000; //接收完成了
}
else //还没收到0X0D
{
if(Res==0x0d)USART_RX_STA|=0x4000;
else
{
USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
USART_RX_STA++;
if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收
}
}
}
}
}
/**
* 功能：初始化UART2---PD5,PD6
* 参数：None
* 返回值：None
*/
void initUART2(u32 BaudRate)
{
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
/*配置USART2和GPIO时钟*/
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);//RCC_APB1Periph_USART2
//串口1对应引脚复用映射
GPIO_PinAFConfig(GPIOD,GPIO_PinSource5,GPIO_AF_USART2); //GPIOA9复用为USART1
GPIO_PinAFConfig(GPIOD,GPIO_PinSource6,GPIO_AF_USART2); //GPIOA10复用为USART1
//USART2端口配置
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6; //GPIOA9与GPIOA10
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //速度50MHz
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽复用输出
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; //上拉
GPIO_Init(GPIOD,&GPIO_InitStructure); //初始化PA9，PA10
//USART1 初始化设置
USART_InitStructure.USART_BaudRate = BaudRate;//波特率设置
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;//无硬件数据流控制
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //收发模式
USART_Init(USART2, &USART_InitStructure); //初始化串口1
USART_Cmd(USART2, ENABLE); //使能串口1
NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn; //指定配置的中断
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; //设置抢占优先级
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //设置子优先级
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //使/失能中断
NVIC_Init(&NVIC_InitStructure); //设置生效
USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
USART_ITConfig(USART2, USART_IT_IDLE, ENABLE);
}
/**
* 功能：指定某个UART发送一个字节
* 参数：USARTx：使用的目标串口x为1-3
* byte：待发送字节
* 返回值：None
*/
void sendByte(USART_TypeDef *USARTx, u16 byte)
{
USART_ClearFlag(USART2, USART_FLAG_TC); //软件清除发送完成标志位
USART_SendData(USARTx, byte); //发送一个字节
while (!USART_GetFlagStatus(USARTx, USART_FLAG_TC));//等待发送完成
USART_ClearFlag(USARTx, USART_FLAG_TC); //软件清除发送完成标志位
}
/**
* 功能：指定某个串口发送字符串
* 参数：USARTx：使用的目标串口x为1-3
* str：字符串指针
* 返回值：None
*/
void sendString(USART_TypeDef *USARTx, char *str)
{
while (*str)
{
sendByte(USARTx,*str++);
}
}
/**
* 功能：串口2中断服务函数
* 参数：None
* 返回值：None
*/
void USART2_IRQHandler(void)
{
static u8 i = 0;
if(USART_GetITStatus(USART2, USART_IT_RXNE)) //判断接收数据寄存器是否有数据
{
RXBuffer[i++] = USART_ReceiveData(USART2);
if(i==RXBUFFER_LEN) //超出接收缓冲范围,可能的情形是ESP8266复位,为防止溢出必须设置索引
{
i = RXBUFFER_LEN-1;
}
}
if(USART_GetITStatus(USART2, USART_IT_IDLE))
{
USART_ReceiveData(USART2); //读一次UART可以清除空闲标志位
i = 0;
processServerBuffer();
}
}
#endif
6.5main.c
#include "sys.h"
#include "delay.h"
#include "led.h"
#include "NetWork.h"
#include "24cxx.h"
#include "myiic.h"
unsigned long Str_Long(char *str);//接接收到的数据，转为长整形，比如1234
unsigned int FindNumInStr(char *str);
unsigned char numbuftemp[9]={0};
void DataBackUp();//备份数据到24C02中
int main(void)
{
int i,t;
char flag8266=0;
unsigned long numtemp=0;
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
delay_init(168); //初始化延时函数
uart_init(115200);//初始化串口波特率为115200
initUART2(115200);//esp8266使用
LED_Init();
delay_ms(10);
//初始化8266，不成功，一直初始化，
while(flag8266!=1){
if(initESP8266()!=0)
{
printf("init ok!\r\n");
flag8266=1;//跳出循环
}else
{
printf("init error!\r\n");
delay_ms(1000);//再次连接，间隔100ms
}
}
//-----------------------------------连接热点
flag8266=0;
while(flag8266!=1){
if(connectAP(SSID,PWD)!=0)
{
printf("conn ap ok!\r\n");
flag8266=1;
}else
{
printf("con ap error!\r\n");
delay_ms(1000);
}
}
//---------------------------------做TCP连接
flag8266=0;
while(flag8266!=1){
if(connectServer(TCP,IP,PORT)!=0)
{
printf("con server ok!\r\n");
flag8266=1;
}else
{
printf("con server error!\r\n");
delay_ms(2000);
}
}
flag8266=0;
// AT24CXX_Init();
// while(AT24CXX_Check())//检测不到24c02
// {
// LCD_ShowNumAsc160(0,9,RED,BLUE,333,3);
// delay_ms(500);
// LCD_ShowNumAsc160(0,9,RED,BLUE,444,3);
// delay_ms(500);
// LED0=!LED0;//DS0闪烁
// }
//连接成功
//将数据读取出来，显示在屏幕上；
//读取数据，显示在屏幕上,第一次使用，需要设置这些数值
//后去使用的话，就可以读取这个出来，不用每次都设置
// YZKQWenDu=AT24CXX_ReadOneByte(0x01); delay_ms(2);
// YZKQShiDu=AT24CXX_ReadOneByte(0x02); delay_ms(2);
// YZTuRangShiDu=AT24CXX_ReadOneByte(0x03); delay_ms(2);
// YZJiaoZhuShiJian=AT24CXX_ReadOneByte(0x04); delay_ms(2);
// YZFengShang=AT24CXX_ReadOneByte(0x05); delay_ms(2);
// YZShuiLiang=AT24CXX_ReadOneByte(0x06); delay_ms(2);
// YZT1Hour=AT24CXX_ReadOneByte(0x07); delay_ms(2);
// YZT1Min=AT24CXX_ReadOneByte(0x08); delay_ms(2);
// YZT2Hour=AT24CXX_ReadOneByte(0x09); delay_ms(2);
// YZT2Min=AT24CXX_ReadOneByte(0x0A); delay_ms(2);
// YZT3Hour=AT24CXX_ReadOneByte(0x0B); delay_ms(2);
// YZT3Min=AT24CXX_ReadOneByte(0x0C); delay_ms(2);
//
while(1) //
{
}
}
/******************************************************************
功能：将一个字符串转为32位长整型变量，比如"1234"转为1234
参数：str:指向待转换的字符串
返回：转换后的数值
******************************************** **********************/
unsigned long Str_Long(char *str)
{
unsigned long temp=0;
unsigned long fact=1;
unsigned char len=strlen(str); // <string.h>头文件包含strlen()函数
unsigned char i; // strlen()函数计算的字符串长度不包含最后一个空字符(值0)
for(i=len;i>0;i--)
{
temp+=((str[i-1]-0x30)*fact); // 数组下标从0开始
fact*=10;
}
return temp;
}
//传入字符串，得到+的下标，然后将两个之间的数据复制到另外一个字符串，然后将该字符串，传出。
unsigned int FindNumInStr(char *str)
{
//找到str里面的等号和#号的下标，每个字符串，设定只能有一个数字
//得到字符串的长度，循环查找是不是相等lcdon=125#A
int i=0;
int j=0;
for(i=0;i<strlen(str);i++)
{
if(str[i]=='+')
{
j=i;
return j;
}
}
return 0;
}
//备份数据到24C02中
void DataBackUp()
{
// //存储数据
// AT24CXX_WriteOneByte(0x01,YZKQWenDu);
// delay_ms(1);
// AT24CXX_WriteOneByte(0x02,YZKQShiDu);
// delay_ms(1);
// AT24CXX_WriteOneByte(0x03,YZTuRangShiDu);
// delay_ms(1);
// AT24CXX_WriteOneByte(0x04,YZJiaoZhuShiJian);
// delay_ms(1);
// AT24CXX_WriteOneByte(0x05,YZFengShang);
// delay_ms(1);
// AT24CXX_WriteOneByte(0x06,YZShuiLiang);
// delay_ms(1);
//
// AT24CXX_WriteOneByte(0x07,YZT1Hour);
// delay_ms(1);
// AT24CXX_WriteOneByte(0x08,YZT1Min);
// delay_ms(1);
// AT24CXX_WriteOneByte(0x09,YZT2Hour);
// delay_ms(1);
// AT24CXX_WriteOneByte(0x0A,YZT2Min);
// delay_ms(1);
// AT24CXX_WriteOneByte(0x0B,YZT3Hour);
// delay_ms(1);
// AT24CXX_WriteOneByte(0x0C,YZT3Min);
// delay_ms(1);
}
6.6主要函数
/**
* 功能：串口2中断服务函数
* 参数：None
* 返回值：None
*/
void USART2_IRQHandler(void)
{
static u8 i = 0;
if(USART_GetITStatus(USART2, USART_IT_RXNE)) //判断接收数据寄存器是否有数据
{
RXBuffer[i++] = USART_ReceiveData(USART2);
if(i==RXBUFFER_LEN) //超出接收缓冲范围,可能的情形是ESP8266复位,为防止溢出必须设置索引
{
i = RXBUFFER_LEN-1;
}
}
if(USART_GetITStatus(USART2, USART_IT_IDLE))
{
USART_ReceiveData(USART2); //读一次UART可以清除空闲标志位
i = 0;
processServerBuffer();
}
}
//传入字符串，得到+的下标，然后将两个之间的数据复制到另外一个字符串，然后将该字符串，传出。
unsigned int FindNumInStr(char *str)
{
//找到str里面的等号和#号的下标，每个字符串，设定只能有一个数字
//得到字符串的长度，循环查找是不是相等lcdon=125#A
int i=0;
int j=0;
for(i=0;i<strlen(str);i++)
{
if(str[i]=='+')
{
j=i;
return j;
}
}
return 0;
}
1539
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
