(补充)基于LPC845及ESP8266的简易WIFI控制器

胤幻1988 · 发表于 2021-5-22 12:47:15

本帖最后由胤幻1988 于 2021-5-22 12:57 编辑

智能家居已经结束。比较惭愧的是，本想用LPC1768做的基于百度云的远程控制器，因为时间关系和LPC1768板子的损坏而告终。
今天周六上班，就搞一个简易版本的，不通过云端，仅基于ESP8266 设置为TCP CLIENT AP模式的控制器。来纪念我那死去的LPC1768。
ESP8266啥的就不多说了。本例程参考了网上一些教程。
本例程的WIFI串口部分，分为2种情况，发送指令配置阶段、透传阶段。
配置阶段仅接收进数值，然后查询数组中，有无期望的应答，来判断该条指令是否正确执行。
透传阶段：接收进数组，并开启一定时器来判断当次传输结束。如果结束就触发中断，置位接收完成标志。
在main函数while循环里面查询接收完成标志，并处理接收的数组，来判断执行相应的控制指令。
本例程，仅仅是论证，控制已路LED，并查询一路KEY状态，模拟读取2中操作。
当然读取状态也可再开1路定时器，在定时器中，定时发送状态。本例初始化代码均由配置工具完成，IDE使用MCUXpresso.
主要的几个外设配置：

WIFI 串口配置程序：

/*
* usart2.c
*
* Created on: 2021年5月20日
* Author: Administrator
*/
#include "usart2.h"
#include "wifi.h"
#include <stdio.h>
#include <stdarg.h>
#include <string.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)
{
usart_config_t USART2N_config = {
.baudRate_Bps = 9600UL,
.syncMode = kUSART_SyncModeDisabled,
.parityMode = kUSART_ParityDisabled,
.stopBitCount = kUSART_OneStopBit,
.bitCountPerChar = kUSART_8BitsPerChar,
.loopback = false,
.enableRx = true,
.enableTx = true,
.clockPolarity = kUSART_RxSampleOnFallingEdge,
.enableContinuousSCLK = false
};
USART2N_config.baudRate_Bps=bound;
/* USART2 peripheral initialization */
USART_Init(USART2_PERIPHERAL, &USART2N_config, USART2_CLOCK_SOURCE);
USART_EnableInterrupts(USART2_PERIPHERAL, kUSART_RxReadyInterruptEnable);
/* Enable interrupt USART2_IRQn request in the NVIC. */
EnableIRQ(USART2_USART_IRQN);
}
/*-------------------------------------------------*/
/*函数名：串口2 printf函数 */
/*参数：char* fmt,... 格式化输出字符串和参数 */
/*返回值：无 */
/*-------------------------------------------------*/
//__attribute__((aligned(16)))
char __attribute__((aligned(8))) 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 (!(kUSART_TxReady & USART_GetStatusFlags(USART2_PERIPHERAL)));
for(i = 0;i < length;i ++)
{
USART_WriteByte(USART2_PERIPHERAL,USART2_TxBuff[i]);
while (!(kUSART_TxReady & USART_GetStatusFlags(USART2_PERIPHERAL)));
}
}
/*-------------------------------------------------*/
/*函数名：串口2发送缓冲区中的数据 */
/*参数：data：数据 */
/*返回值：无 */
/*-------------------------------------------------*/
void u2_TxData(unsigned char *data)
{
int i;
while (!(kUSART_TxReady & USART_GetStatusFlags(USART2_PERIPHERAL)));
for(i = 1;i <= data[0];i ++){
USART_WriteByte(USART2_PERIPHERAL,USART2_TxBuff[i]);
while (!(kUSART_TxReady & USART_GetStatusFlags(USART2_PERIPHERAL)));
}
}
/*-------------------------------------------------*/
/*函数名：串口3接收中断函数 */
/*参数：无 */
/*返回值：无 */
/*-------------------------------------------------*/
/* USART2_IRQn interrupt handler */
void USART2_USART_IRQHANDLER(void)
{
/* Place your code here */
uint8_t data;
/* If this Rx read flag is set, read data to buffer. */
if (kUSART_RxReady & USART_GetStatusFlags(USART2_PERIPHERAL))
{
data = USART_ReadByte(USART2_PERIPHERAL);
if(Connect_flag==0) //如果Connect_flag等于0，当前还没有连接服务器，处于指令配置状态
{
if(data)
{
Usart2_RxBuff[Usart2_RxCounter]=data; //保存到缓冲区
Usart2_RxCounter ++; //每接收1个字节的数据，Usart2_RxCounter加1，表示接收的数据总量+1
}
}
else
{
Usart2_RxBuff[Usart2_RxCounter] = data; //把接收到的数据保存到Usart2_RxBuff中
if(Usart2_RxCounter == 0)
{ //如果Usart2_RxCounter等于0，表示是接收的第1个数据，进入if分支
//TIM_Cmd(TIM4,ENABLE);
CTIMER_StartTimer(CTIMER0_PERIPHERAL);
}
else
{ //else分支，表示果Usart2_RxCounter不等于0，不是接收的第一个数据
//TIM_SetCounter(TIM4,0);
CTIMER0_PERIPHERAL->TC=0;
}
Usart2_RxCounter ++; //每接收1个字节的数据，Usart2_RxCounter加1，表示接收的数据总量+1
}
}
/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F
Store immediate overlapping exception return operation might vector to incorrect interrupt. */
#if defined __CORTEX_M && (__CORTEX_M == 4U)
__DSB();
#endif
}

复制代码

判断串口发送结束的定时器配置程序：

/* clang-format on */
const ctimer_config_t CTIMER0_config = {
.mode = kCTIMER_TimerMode,
.input = kCTIMER_Capture_0,
.prescale = 29
};
const ctimer_match_config_t CTIMER0_Match_0_config = {
.matchValue = 1000,
.enableCounterReset = true,
.enableCounterStop = false,
.outControl = kCTIMER_Output_NoAction,
.outPinInitState = false,
.enableInterrupt = true
};
/* Single callback functions definition */
ctimer_callback_t CTIMER0_callback[] = {CTIMER0_Singlecallback};
static void CTIMER0_init(void) {
/* CTIMER0 peripheral initialization */
CTIMER_Init(CTIMER0_PERIPHERAL, &CTIMER0_config);
/* Match channel 0 of CTIMER0 peripheral initialization */
CTIMER_SetupMatch(CTIMER0_PERIPHERAL, CTIMER0_MATCH_0_CHANNEL, &CTIMER0_Match_0_config);
CTIMER_RegisterCallBack(CTIMER0_PERIPHERAL, CTIMER0_callback, kCTIMER_SingleCallback);
}
static uint32_t i = 0;
void CTIMER0_Singlecallback(uint32_t flags)
{
i++;
if(i>=30) //周期1ms 30ms
{
i=0;
//LED_RED_TOGGLE();
Usart2_RxCompleted = 1; //串口2接收完成标志位置位
memcpy(&Data_buff[2],Usart2_RxBuff,Usart2_RxCounter); //拷贝数据
Data_buff[0] = WiFi_RxCounter/256; //记录接收的数据量
Data_buff[1] = WiFi_RxCounter%256; //记录接收的数据量
Data_buff[WiFi_RxCounter+2] = '\0'; //加入结束符
WiFi_RxCounter=0; //清零计数值
CTIMER_StopTimer(CTIMER0_PERIPHERAL); //关闭CTIM0定时器
CTIMER0_PERIPHERAL->TC=0; //清零CTIM0计数器
}
}

复制代码

WIFI配置程序：

/*
* wifi.c
*
* Created on: 2021年5月21日
* Author: Administrator
*/
#include "wifi.h"
#include "delay.h" //包含需要的头文件
#include "led.h" //包含需要的头文件
#include "key.h" //包含需要的头文件
#include <stdio.h>
/*-----------------------------------------------------------------------------*/
/* 根据自己的网络环境修改 */
/*-----------------------------------------------------------------------------*/
char *ServerIP = "192.168.10.2"; //存放服务器IP或是域名
int ServerPort = 5050; //存放服务器的端口号区
/*-----------------------------------------------------------------------------*/
char Data_buff[2048]; //数据缓冲区
char wifi_mode = 1; //联网模式 0：SSID和密码写在程序里 1：Smartconfig方式用APP发送
char Connect_flag; //同服务器连接状态 0：还没有连接服务器 1：连接上服务器了
/*-------------------------------------------------*/
/*函数名：初始化WiFi的复位IO */
/*参数：无 */
/*返回值：无 */
/*-------------------------------------------------*/
void WiFi_ResetIO_Init(void)
{
/* Enables the clock for the GPIO1 module */
CLOCK_EnableClock(kCLOCK_Gpio1);
gpio_pin_config_t gpio1_pin1_6 = {
.pinDirection = kGPIO_DigitalOutput,
.outputLogic = 1U,
};
/* Initialize GPIO functionality on pin PIO1_6 (pin ) */
GPIO_PinInit(GPIO, 1U, 6U, &gpio1_pin1_6);
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循环
u0_printf("%d ",timeout); //串口输出现在的超时时间
}
u0_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循环
u0_printf("%d ",timeout); //串口输出现在的超时时间
}
u0_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循环
u0_printf("%d ",timeout); //串口输出现在的超时时间
}
u0_printf("\r\n"); //串口输出信息
if(timeout<=0)return 1; //如果timeout<=0，说明超时时间到了，也没能收到WIFI GOT IP，返回1
return 0; //正确，返回0
}
/*-------------------------------------------------*/
/*函数名：WiFi_Smartconfig */
/*参数：timeout：超时时间（1s的倍数） */
/*返回值：0：正确其他：错误 */
/*-------------------------------------------------*/
char WiFi_Smartconfig(int timeout)
{
WiFi_RxCounter=0; //WiFi接收数据量变量清零
memset(WiFi_RX_BUF,0,WiFi_RXBUFF_SIZE); //清空WiFi接收缓冲区
while(timeout--){ //等待超时时间到0
Delay_Ms(1000); //延时1s
if(strstr(WiFi_RX_BUF,"connected")) //如果串口接受到connected表示成功
break; //跳出while循环
u0_printf("%d ",timeout); //串口输出现在的超时时间
}
u0_printf("\r\n"); //串口输出信息
if(timeout<=0)return 1; //超时错误，返回1
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循环
u0_printf("%d ",timeout); //串口输出现在的超时时间
}
u0_printf("\r\n"); //串口输出信息
if(timeout<=0)return 1; //如果timeout<=0，说明超时时间到了，也没能收到WIFI GOT IP，返回1
return 0; //正确，返回0
}
/*-------------------------------------------------*/
/*函数名：等待连接wifi，获取IP地址 */
/*参数：ip：保存IP的数组 */
/*参数：timeout：超时时间（100ms的倍数） */
/*返回值：0：正确其他：错误 */
/*-------------------------------------------------*/
char WiFi_GetIP(int timeout)
{
char *presult1,*presult2;
char ip[50];
WiFi_RxCounter=0; //WiFi接收数据量变量清零
memset(WiFi_RX_BUF,0,WiFi_RXBUFF_SIZE); //清空WiFi接收缓冲区
WiFi_printf("AT+CIFSR\r\n"); //发送指令
while(timeout--){ //等待超时时间到0
Delay_Ms(100); //延时100ms
if(strstr(WiFi_RX_BUF,"OK")) //如果接收到OK表示成功
break; //主动跳出while循环
u0_printf("%d ",timeout); //串口输出现在的超时时间
}
u0_printf("\r\n"); //串口输出信息
if(timeout<=0)return 1; //如果timeout<=0，说明超时时间到了，也没能收到OK，返回1
else{
presult1 = strstr(WiFi_RX_BUF,""");
if( presult1 != NULL ){
presult2 = strstr(presult1+1,""");
if( presult2 != NULL ){
memcpy(ip,presult1+1,presult2-presult1-1);
u0_printf("ESP8266 IP address：%s\r\n",ip); //串口显示IP地址
return 0; //正确返回0
}else return 2; //未收到预期数据
}else return 3; //未收到预期数据
}
}
/*-------------------------------------------------*/
/*函数名：获取连接状态 */
/*参数：无 */
/*返回值：连接状态 */
/* 0：无状态 */
/* 1：有客户端接入 */
/* 2：有客户端断开 */
/*-------------------------------------------------*/
char WiFi_Get_LinkSta(void)
{
char id_temp[10]={0}; //缓冲区，存放ID
char sta_temp[10]={0}; //缓冲区，存放状态
if(strstr(WiFi_RX_BUF,"CONNECT")){ //如果接受到CONNECT表示有客户端连接
sscanf(WiFi_RX_BUF,"%[^,],%[^,]",id_temp,sta_temp);
u0_printf("client connect,ID=%s\r\n",id_temp); //串口显示信息
WiFi_RxCounter=0; //WiFi接收数据量变量清零
memset(WiFi_RX_BUF,0,WiFi_RXBUFF_SIZE); //清空WiFi接收缓冲区
return 1; //有客户端接入
}else if(strstr(WiFi_RX_BUF,"CLOSED")){ //如果接受到CLOSED表示有链接断开
sscanf(WiFi_RX_BUF,"%[^,],%[^,]",id_temp,sta_temp);
u0_printf("client disconnect,ID=%s\r\n",id_temp); //串口显示信息
WiFi_RxCounter=0; //WiFi接收数据量变量清零
memset(WiFi_RX_BUF,0,WiFi_RXBUFF_SIZE); //清空WiFi接收缓冲区
return 2; //有客户端断开
}else return 0; //无状态改变
}
/*-------------------------------------------------*/
/*函数名：获取客户端数据 */
/* 两组回车换行符\r\n\r\n作为数据的结束符 */
/*参数：data：数据缓冲区 */
/*参数：len：数据量 */
/*参数：id：发来数据的客户端的连接ID */
/*返回值：数据状态 */
/* 0：无数据 */
/* 1：有数据 */
/*-------------------------------------------------*/
char WiFi_Get_Data(char *data, char *len, char *id)
{
char temp[10]={0}; //缓冲区
char *presult;
if(strstr(WiFi_RX_BUF,"\r\n\r\n")){ //两个连着的回车换行作为数据的结束符
sscanf(WiFi_RX_BUF,"%[^,],%[^,],%[^:]",temp,id,len);//截取各段数据，主要是id和数据长度
presult = strstr(WiFi_RX_BUF,":"); //查找冒号。冒号后的是数据
if( presult != NULL ) //找到冒号
sprintf((char *)data,"%s",(presult+1)); //冒号后的数据，复制到data
WiFi_RxCounter=0; //WiFi接收数据量变量清零
memset(WiFi_RX_BUF,0,WiFi_RXBUFF_SIZE); //清空WiFi接收缓冲区
return 1; //有数据到来
} else return 0; //无数据到来
}
/*-------------------------------------------------*/
/*函数名：服务器发送数据 */
/*参数：databuff：数据缓冲区<2048 */
/*参数：data_len：数据长度 */
/*参数：id：客户端的连接ID */
/*参数：timeout：超时时间（10ms的倍数） */
/*返回值：错误值 */
/* 0：无错误 */
/* 1：等待发送数据超时 */
/* 2：连接断开了 */
/* 3：发送数据超时 */
/*-------------------------------------------------*/
char WiFi_SendData(char id, char *databuff, int data_len, int timeout)
{
int i;
WiFi_RxCounter=0; //WiFi接收数据量变量清零
memset(WiFi_RX_BUF,0,WiFi_RXBUFF_SIZE); //清空WiFi接收缓冲区
WiFi_printf("AT+CIPSEND=%d,%d\r\n",id,data_len); //发送指令
while(timeout--){ //等待超时与否
Delay_Ms(10); //延时10ms
if(strstr(WiFi_RX_BUF,">")) //如果接收到>表示成功
break; //主动跳出while循环
u0_printf("%d ",timeout); //串口输出现在的超时时间
}
if(timeout<=0)return 1; //超时错误，返回1
else{ //没超时，正确
WiFi_RxCounter=0; //WiFi接收数据量变量清零
memset(WiFi_RX_BUF,0,WiFi_RXBUFF_SIZE); //清空WiFi接收缓冲区
for(i=0;i<data_len;i++)WiFi_printf("%c",databuff[i]); //发送数据
while(timeout--){ //等待超时与否
Delay_Ms(10); //延时10ms
if(strstr(WiFi_RX_BUF,"SEND OK")){ //如果接受SEND OK，表示发送成功
WiFi_RxCounter=0; //WiFi接收数据量变量清零
memset(WiFi_RX_BUF,0,WiFi_RXBUFF_SIZE); //清空WiFi接收缓冲区
break; //跳出while循环
}
if(strstr(WiFi_RX_BUF,"link is not valid")){ //如果接受link is not valid，表示连接断开
WiFi_RxCounter=0; //WiFi接收数据量变量清零
memset(WiFi_RX_BUF,0,WiFi_RXBUFF_SIZE); //清空WiFi接收缓冲区
return 2; //返回2
}
}
if(timeout<=0)return 3; //超时错误，返回3
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
u0_printf("%d ",timeout); //串口输出现在的超时时间
}
u0_printf("\r\n"); //串口输出信息
if(timeout<=0)return 3; //超时错误，返回3
else //连接成功，准备进入透传
{
u0_printf("start in dirsend mode\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循环
u0_printf("%d ",timeout); //串口输出现在的超时时间
}
if(timeout<=0)return 4; //透传超时错误，返回4
}
return 0; //成功返回0
}
/*-------------------------------------------------*/
/*函数名：设置AP */
/*参数：ssid：ssid */
/*参数：password：密码 */
/*参数：mode:加密方式 */
/*参数：timeout ：超时时间 */
/*返回值：0；正确其他：错误 */
/*-------------------------------------------------*/
char WiFi_SET_AP(char *ssid, char *password, char mode, int timeout)
{
WiFi_RxCounter=0; //WiFi接收数据量变量清零
memset(WiFi_RX_BUF,0,WiFi_RXBUFF_SIZE); //清空WiFi接收缓冲区
WiFi_printf("AT+CWSAP="%s","%s",4,%d\r\n",ssid,password,mode); //发送设置AP指令
while(timeout--){ //等待超时时间到0
Delay_Ms(100); //延时100ms
if(strstr(WiFi_RX_BUF,"OK")) //如果接收到OK表示指令成功
break; //主动跳出while循环
u0_printf("%d ",timeout); //串口输出现在的超时时间
}
u0_printf("\r\n"); //串口输出信息
if(timeout<=0)return 1; //如果timeout<=0，说明超时时间到了，也没能收到OK，返回1
else return 0; //反之，表示正确，说明收到OK，通过break主动跳出while
}
/*-------------------------------------------------*/
/*函数名：连接服务器 */
/*参数：无 */
/*返回值：0：正确其他：错误 */
/*-------------------------------------------------*/
char WiFi_ConnectServer_AP(void)
{
char res;
char temp[50];
u0_printf("reset module\r\n"); //串口提示数据
if(WiFi_Reset(50)){ //复位，100ms超时单位，总计5s超时时间
u0_printf("reset fail,try reset...\r\n"); //返回非0值，进入if，串口提示数据
return 1; //返回1
}else u0_printf("reset ok!\r\n"); //串口提示数据
u0_printf("Try set AP mode\r\n"); //串口提示数据
if(WiFi_SendCmd("AT+CWMODE=2",50)){ //设置AP模式，100ms超时单位，总计5s超时时间
u0_printf("set AP mode,try reset...\r\n"); //返回非0值，进入if，串口提示数据
return 2; //返回2
}else u0_printf("set AP mode OK\r\n"); //串口提示数据
u0_printf("start set AP para\r\n"); //串口提示数据
u0_printf("SSID：%s\r\n",SSID); //串口提示数据
u0_printf("key：%s\r\n",PASS); //串口提示数据
u0_printf("AP IP：%s\r\n",AP_IP); //串口提示数据
u0_printf("key mode：WPA_WPA2_PSK\r\n"); //串口提示数据
u0_printf("start set AP IP\r\n"); //串口提示数据
memset(temp,0,50); //清除临时缓冲区
sprintf(temp,"AT+CIPAP="%s"",AP_IP); //构建命令
if(WiFi_SendCmd(temp,50)){ //设置AP热点IP，100ms超时单位，总计5s超时时间
u0_printf("set AP IP fail，start reset\r\n"); //返回非0值，进入if，串口提示数据
return 3; //返回3
}else u0_printf("set AP IP ok\r\n"); //串口提示数据
u0_printf("start set AP para\r\n"); //串口提示数据
if(WiFi_SET_AP(SSID,PASS,WPA_WPA2_PSK,50)){ //设置AP参数，100ms超时单位，总计5s超时时间
u0_printf("set AP para fail,start reset\r\n"); //返回非0值，进入if，串口提示数据
return 4; //返回4
}else u0_printf("set AP para ok\r\n"); //串口提示数据
u0_printf("start open dirsend\r\n"); //串口提示数据
if(WiFi_SendCmd("AT+CIPMODE=1",50)){ //开启透传，100ms超时单位，总计5s超时时间
u0_printf("open dirsend fail,start reset\r\n"); //返回非0值，进入if，串口提示数据
return 5; //返回5
}else u0_printf("close dirsend ok\r\n"); //串口提示数据
u0_printf("start close multiconnect\r\n"); //串口提示数据
if(WiFi_SendCmd("AT+CIPMUX=0",50)){ //关闭多路连接，100ms超时单位，总计5s超时时间
u0_printf(" close multiconnect fail,start reset\r\n"); //返回非0值，进入if，串口提示数据
return 6; //返回6
}else u0_printf("close multiconnect ok\r\n"); //串口提示数据
Connect:
u0_printf("start connect server\r\n"); //串口提示数据
res = WiFi_Connect_Server(100); //连接服务器，100ms超时单位，总计10s超时时间
if(res==1){ //返回值=1，进入if
u0_printf("connect server fail,try reconnect\r\n"); //串口提示数据
Delay_Ms(2000); //延时
goto Connect; //跳转到Connect重连
}else if(res==2){ //返回值=2，进入if
u0_printf("connect already exist\r\n"); //串口提示数据
}else if(res==3){ //返回值=3，进入if
u0_printf("connect server out time,try reconnect\r\n"); //串口提示数据
return 7; //返回7
}else if(res==4){ //返回值=4，进入if
u0_printf("open dirsend fail\r\n"); //串口提示数据
return 8; //返回8
}
u0_printf("connect server OK\r\n"); //串口提示数据
return 0; //正确返回0
}

复制代码

/*
* wifi.h
*
* Created on: 2021年5月21日
* Author: Administrator
*/
#ifndef WIFI_H_
#define WIFI_H_
#include "usart2.h" //包含需要的头文件
#include "fsl_debug_console.h"
#include "pin_mux.h"
#include "delay.h"
#define u0_printf PRINTF
extern char Connect_flag; //外部变量声明，同服务器连接状态 0：还没有连接服务器 1：连接上服务器了
#define BOARD_INITPINS_wifi_rest_GPIO GPIO /*!<@brief GPIO peripheral base pointer */
#define BOARD_INITPINS_wifi_rest_GPIO_PIN_MASK (1U << 6U) /*!<@brief GPIO pin mask */
#define BOARD_INITPINS_wifi_rest_PORT 1U /*!<@brief PORT device index: 1 */
#define BOARD_INITPINS_wifi_rest_PIN 6U /*!<@brief PORT pin number */
#define BOARD_INITPINS_wifi_rest_PIN_MASK (1U << 6U) /*!<@brief PORT pin mask */
/* @} */
#define RESET_IO_L GPIO_PortClear(BOARD_INITPINS_wifi_rest_GPIO, BOARD_INITPINS_wifi_rest_PORT, \
1U << BOARD_INITPINS_wifi_rest_PIN) /*!< Turn on target LED_GREEN \ \ \ \ \
*/
#define RESET_IO_H GPIO_PortSet (BOARD_INITPINS_wifi_rest_GPIO, BOARD_INITPINS_wifi_rest_PORT, \
1U << BOARD_INITPINS_wifi_rest_PIN)
#define RESET_IO(x) (x>0)?RESET_IO_H:RESET_IO_L //PA4控制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 Delay_Ms delay_ms
#define SSID "ESP8266-AP" //路由器SSID名称
#define PASS "123456789" //路由器密码
#define WPA_WPA2_PSK 4 //加密方式
#define AP_IP "192.168.10.1" //AP热点的ip
extern char *ServerIP; //存放服务器IP或是域名
extern int ServerPort; //存放服务器的端口号区
extern char Data_buff[2048]; //数据缓冲区
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_GetIP(int timeout);
char WiFi_Get_LinkSta(void);
char WiFi_Get_Data(char *data, char *len, char *id);
char WiFi_SendData(char id, char *databuff, int data_len, int timeout);
char WiFi_Connect_Server(int timeout);
char WiFi_SET_AP(char *ssid, char *password, char mode, int timeout);
char WiFi_ConnectServer_AP(void);
#endif /* WIFI_H_ */

复制代码

main函数中调用：

WiFi_ResetIO_Init(); //初始化WiFi的复位IO
while(WiFi_ConnectServer_AP()){ //循环，初始化，连接服务器，直到成功
Delay_Ms(2000); //延时
}
WiFi_RxCounter=0; //WiFi接收数据量变量清零
memset(WiFi_RX_BUF,0,WiFi_RXBUFF_SIZE); //清空WiFi接收缓冲区
Connect_flag = 1; //Connect_flag=1,表示连接上服务器
while(1){
if(Usart2_RxCompleted==1){ //如果Usart2_RxCompleted等于1，表示接收数据完成
Usart2_RxCompleted = 0; //清除标志位
u0_printf("the server send %d byte date\r\n",(Data_buff[0]*256+Data_buff[1])); //串口输出信息
u0_printf("data:%s\r\n",&Data_buff[2]); //串口输出信息
WiFi_printf("you send data:%s\r\n",&Data_buff[2]); //把接收到的数据，返回给服务器
//判断指令，执行操作
//写控制
if (strstr(&Data_buff[2],"LED ON")) LED_RED_ON();
if (strstr(&Data_buff[2],"LED OFF")) LED_RED_OFF();
//读控制
if (strstr(&Data_buff[2],"KEY VALUE")) WiFi_printf("KEY VALUE IS:%d\r\n",key_wakeup);
}
if(time>=1000){ //当time大于等于1000的时候，大概经过1s的时间
time=0; //清除time计数
WiFi_printf("I'm client,send me data!\r\n"); //给服务器发送数据
}
Delay_Ms(1); //延时1ms
time++; //time计数器+1
}

复制代码

编译无误后，下载程序，发现串口输出信息卡在连接服务器这里：

拿出手机，连接热点，并配置服务器：
1、连接到ESP8266 AP的WIFI网络上：
当前热点帐号密码：

手机连接上AP：

打开手机网络调试助手，在TCP SERVER 一栏添加一个服务器端口
设置为5050，要与程序中的一致,,设置好后，可看到IP地址：

发送数据，板子做出应答：
CLIENT接收到SERVER发送的任何数据，均会重新发回来：

发送对应指令：LED ON 会打开板子LED，LED OFF 关闭板子LED ,
KEY VALUE 发送按键当前状态。

板子实物图。

好了，今天的分享就到这了。谢谢观看~

阅读全文

jobszheng5 · 发表于 2021-5-22 14:36:38

现在一颗LPC1768也得过百元了吧

胤幻1988 · 发表于 2021-5-22 15:08:49

jobszheng5 发表于 2021-5-22 14:36
现在一颗LPC1768也得过百元了吧

根本还买不到上次有人说都要400一颗了准备换芯片了~

jobszheng5 · 发表于 2021-5-23 16:53:06

听楼主这么一说，我手里的LPC1176的开发板都不敢玩了

maoyanmcu · 发表于 2021-5-24 10:55:00

芯片涨价涨的厉害啊！

[智能家居挑战赛] (补充)基于LPC845及ESP8266的简易WIFI控制器

热心会员

站长推荐 /4