前言
今天这一讲注意涉及到WiFi模块ESP8266的使用，主要是用WiFi来控制LED0亮灭，包括会详细介绍一下该模块的使用，废话不多说，正题进入···

0 j. x$ [9 e: x一、ESP8266介绍
9 C7 ?1 J" j, {/ t9 }6 r: Y; o互联网+时代，无线传输、无线通信尤为重要，那么在WiFi通信方面就数ESP8266用的最为广泛了，因为ESP8266是一个具备高性能的模块，在不了解其原理的情况下，只要有一定的串口知识理解，那么就可以轻松上手该模块，进而实现手机WiFi操作。简单来说，就是利用编程来实现WiFi模块的透明传输。
: F6 M: t8 ~2 t0 v7 p6 ^2 X4 x

0 D7 v! K9 O# h4 t# x
* M: m4 R2 d  b5 U/ g/ U4 o3 t 这里我们看到该模块有8个接口，但是实际上我们只需要用到五个接口就可以操作这个WiFi模块了，主要是3.3V、GND、RXD、TXD、EN这五个接口可以看上图，RXD接单片机上的TXD接口（这里我用的是串口3，所以接PB10），TXD接单片机上的RXD接口（即PB11），EN接3.3V即可。
3 W7 I2 i7 r" O, j' x  |
, q6 Z1 [7 g# k8 Y那么他有哪些指令呢？
5 B$ ~, t! F( D
6 T& q1 i+ w$ q' [$ k这里你会发现它有三种模式即STA、AP、混合，那么我们该如何使用呢，这里简单说明一下
7 S2 \- L" K5 l  T' w6 A1 ^( }
STA模式就是类似一个接收模式，就是开启该模式后，你只能通过串口给他发送信息，ESP8266只负责接收，而不会产生一个热点，（手机或其他设备是找不到热点的）然后这模式我一般会直接用来调试各种AT指令，通过串口调试助手进行数据传输

AP模式就简单了，就是它发出去一个热点，供手机或其他设备连接，如果要实现手机连热点来控制单片机，那么该模式就要开启了。
0 M% Q, _' L' ]" W7 n
2 T0 @0 }' Q& Y% @混合模式就是两者同时实现。
1 m( }+ \" C7 ~2 l% p
接下来关于传输的方式，一般都是采用透传比较好，如果不采用透传模式，那么每发送一次数据都要发送一次AT+CIPSEND=<param>的指令就显得尤为麻烦，因此模式一般设置为透传模式，退出透传模式就给指令“+++”即可，后面代码里也有具体涉及到透传模式的退出操作，后面代码再一一介绍。
; \) k5 Q0 Z% m5 u' H' m+ p
二、如何实现WiFi传输？代码详解附上
6 m* r  u9 L  j& d串口3初始化函数：
- _7 F5 B6 N+ V, O, Y; g6 Z

1. #include "delay.h"
   3 P# _! [; U1 k, a
2. #include "usart3.h"
   ' W0 y, q3 D0 p$ D: I
3. #include "stdarg.h"                  
   * o$ I; }4 ~+ P% \
4. #include "stdio.h"                  
   
5. #include "string.h"         
   6 V: F& k- e$ L. }8 B8 U
6. #include "timer.h"
   3 M2 e' d; g8 e' o4 N
7. 
   
8.         u8 res;        
   ; `8 D4 o3 D# y, u
9. //串口接收发送缓存区               
   , z$ V, ]/ Y9 q# ]
10. u8 USART3_RX_BUF[USART3_MAX_RECV_LEN];                        
    + t! N. U8 f( ^8 A
11. u8  USART3_TX_BUF[USART3_MAX_SEND_LEN];                 
    
12. 
    - l& x% @8 f6 l/ x* N5 c6 z
13. 
    
14. 
    
15. vu16 USART3_RX_STA=0;           
    
16. 
    
17. //串口3中断
    : _- R9 I7 n8 j, f
18. void USART3_IRQHandler(void)
    ; e. E5 ~. }1 p' C% O. C* R
19. {
    
20. 
    & b7 Z/ p0 k4 Y% t* F9 K
21.         if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
    . \7 I. [- r4 S0 s
22.         {         
    $ E' R5 q& u! ]
23.                 res =USART_ReceiveData(USART3);                 
    
24.                 if((USART3_RX_STA&(1<<15))==0)
    ! f9 M: S; Z8 S: ]1 e# F
25.                 {
    5 A- }* ^# v7 Y% F: }4 e
26.                         if(USART3_RX_STA<USART3_MAX_RECV_LEN)        
    7 w7 I) E% {# w/ Y5 d7 @0 w
27.                         {
    6 D6 x0 m" \0 S7 X
28.                                 TIM_SetCounter(TIM7,0);                                         
    
29.                                 if(USART3_RX_STA==0)                                 
    
30.                                 {
    
31.                                         TIM_Cmd(TIM7,ENABLE);
    
32.                                 }
    
33.                                 USART3_RX_BUF[USART3_RX_STA++]=res;        
    
34.                         }else
    
35.                         {
    
36.                                 USART3_RX_STA|=1<<15;                        
    
37.                         }
    ( j& r( C. g% {! J
38.                 }
    
39.         }                                                                                                                           
    
40. }   
    
41. 
    
42. //串口3初始化
    
43. void usart3_init(u32 bound)
    " k7 c8 V8 Z& F5 N0 V, c" `
44. {  
    
45. 
    0 x/ L4 G9 y/ o. h8 L& e0 n+ c
46.         NVIC_InitTypeDef NVIC_InitStructure;
    
47.         GPIO_InitTypeDef GPIO_InitStructure;
    
48.         USART_InitTypeDef USART_InitStructure;
    
49. 
    
50.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);        
    
51.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3,ENABLE);
    2 C2 O& A4 g) T& V2 I
52. 
    ! Z- T4 {' Q& t  i
53.          USART_DeInit(USART3);
    5 R/ {" W) @1 K1 f! d; q/ `
54.                  //USART3_TX   PB10
    
55.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    + q* s' r" J- ~0 S& ]
56.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    4 l7 k( P9 Y; b* o5 C
57.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    2 U! z6 P/ Y2 d6 D
58.   GPIO_Init(GPIOB, &GPIO_InitStructure);
    
59. 
    
60.     //USART3_RX          PB11
    ) \7 F0 p/ C! J# E( r+ D
61.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
    7 F- ?  |8 j' f: J! F$ }
62.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
63.   GPIO_Init(GPIOB, &GPIO_InitStructure);
    
64.         
    + A) r6 e, l- |! ^
65.         USART_InitStructure.USART_BaudRate = bound;
    
66.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    0 k7 U6 a, s; G
67.         USART_InitStructure.USART_StopBits = USART_StopBits_1;
    
68.         USART_InitStructure.USART_Parity = USART_Parity_No;
    4 Z: e5 o* o" Q$ Z
69.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    
70.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        
    ; ?* x* G- e. m4 P6 a' D
71. 
    7 {# c8 F7 @. H9 K  s
72.         USART_Init(USART3, &USART_InitStructure);
    0 O. ^/ m( L5 b, v. H# y
73. 
    
74. 
    * e: V, T& @  d: Y% C# E
75.         USART_Cmd(USART3, ENABLE);              
    
76.         
    
77. 
    / c, U: K' s6 [8 U8 [5 b8 e
78.   USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);
    ; S: a5 U( p+ u" C* N
79.         
    
80. 
    ) ~6 h$ X# o+ j. x. B( \
81.         NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
    
82.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2 ;
    " t0 v; e" x1 G, R, E$ L. c8 a
83.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;               
    " G1 K- g5 @7 i
84.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        
    . s7 y! u: d3 w& ?8 i1 q5 O
85.         NVIC_Init(&NVIC_InitStructure);        
    ' ?& P5 l6 a0 ?; k7 s: m" ^
86.         
      R# W; B1 O  m+ e
87.         
    7 O! K7 o5 [, o+ r# N
88.         TIM7_Int_Init(1000-1,7200-1);               
    
89.         USART3_RX_STA=0;               
    0 ~7 O" P* Q% W, M  ]; ?0 J
90.         TIM_Cmd(TIM7,DISABLE);                        
    
91. 
    
92. }
    
93. //串口3printf函数，保证输入不大于设定长度
    9 l4 `6 L/ B  Y* ]+ a
94. void u3_printf(char* fmt,...)  
    # b+ m. o* \* U/ g" u
95. {  
    4 q; M5 J7 r& D8 u
96.         u16 i,j;
    
97.         va_list ap;
    
98.         va_start(ap,fmt);
    ( E+ j% G/ f1 L7 R7 ~/ i5 x3 d5 F
99.         vsprintf((char*)USART3_TX_BUF,fmt,ap);
    ( @& ?4 }( m9 L. l
100.         va_end(ap);
     
101.         i=strlen((const char*)USART3_TX_BUF);               
     
102.         for(j=0;j<i;j++)                                                
     ! X, G9 F" P9 n! E4 F! s! K
103.         {
     
104.           while(USART_GetFlagStatus(USART3,USART_FLAG_TC)==RESET);
     0 `! g/ g) U: t7 O
105.                 USART_SendData(USART3,USART3_TX_BUF[j]);
     
106.         }
     
107. }
     

复制代码

ESP8266初始化函数：

* B( S: D3 L) k( M/ l: j- p5 W: k* K+ @

1. #include "esp8266.h"
   " n& L0 z( E0 y+ ~. t; g
2. #include "string.h"
   0 j+ L3 l! H; R: n
3. #include "usart.h"
   
4. #include "usart3.h"
   
5. #include "stm32f10x.h"
   
6. #include "sys.h"
   # b8 P* W3 g" q
7. #include "delay.h"
   
8. #include "lcd.h"
   
9. 
   8 }( s) X& A+ k2 e: F
10. //ESP8266初始化
    
11. void esp8266_start_trans(void)
    . q/ N: V0 [5 B
12. {
    ' y: `1 O9 Y7 W7 I. p. j3 J% x" P
13.         
    ' V# w" M  C* R9 c, p, l& E
14.         esp8266_send_cmd("AT+CWMODE=2","OK",50);//设置为AP模式
    ) u' h% |( K# w- V
15. 
    
16.         esp8266_send_cmd("AT+RST","ready",20);//重启
    
17.         
    
18.         delay_ms(1000);      
    
19.         delay_ms(1000);
    & j: s$ g9 Q0 ~; p. }: F, ?, Z
20.         delay_ms(1000);
    
21.         delay_ms(1000);
    ! f* f+ _, x2 B% s& a
22.         
    1 o! d) a& @* J8 W( P' \
23.         esp8266_send_cmd("AT+CWSAP="ESP8266","12345678",1,4","OK",200);//设置WiFi名称、密码，模式
    
24.         esp8266_send_cmd("AT+CIPMUX=1","OK",20);//进入透传模式
    - M& c: z  i4 L# Y0 b: X8 S. A
25.         esp8266_send_cmd("AT+CIPSERVER=1,8080","OK",200);//设置端口8080
    9 I; R2 {+ |4 ^! v8 i& ~
26.         esp8266_send_cmd("AT+CIPSEND","OK",50);//开始发送数据
    
27. }
    , m* f* L5 \  w' h4 A* }4 h8 ^6 [$ S
28. 
    & S7 L3 Z  `4 S1 v% x' U
29. //退出透传模式
    / j" X( ]% ?& y
30. u8 esp8266_quit_trans(void)
    
31. {
    9 S- P% I) D! J# o2 E1 L
32.         u8 result=1;
    ( j" g. m4 n* w8 C$ ]% W8 H& m
33.         u3_printf("+++");
    8 ?& }" a) B. T2 f. U
34.         delay_ms(1000);                                       
    ! }7 u. c, c3 m% x2 T1 Y
35.         result=esp8266_send_cmd("AT","OK",20);
    
36.         if(result)
    
37.                 printf("quit_trans failed!");
    
38.         else
    
39.                 printf("quit_trans success!");
    
40.         return result;
    7 M" X$ h" u  @
41. }
    
42. 
      s. ~2 l, g, ~) ~; Y! s( R" J8 k1 A
43. //发送指令，返回0发送成功，1则失败
      S/ G1 M. P' o7 h- A
44. u8 esp8266_send_cmd(u8 *cmd,u8 *ack,u16 waittime)
    
45. {
    
46.         u8 res=0;
    ! G* Y9 c( \0 i, D$ X- }1 G" P9 C
47.         USART3_RX_STA=0;
    - _) _6 U; h9 B! m, j: G
48.         u3_printf("%s\r\n",cmd);        
    
49.         if(ack&&waittime)               
    $ x7 e9 M* ]" T8 Y9 L
50.         {
    : w  S/ R# a) V  ^7 U" n% j
51.                 while(--waittime)        
    . L5 x+ Q6 w9 v+ W; K0 @
52.                 {
    $ l: K/ X( R  ?7 |% H( P8 c
53.                         delay_ms(10);
    
54.                         if(USART3_RX_STA&0X8000)
    1 L( y, P  w9 E' u& f7 |2 s3 f0 U
55.                         {
    
56.                                 if(esp8266_check_cmd(ack))
    
57.                                 {
    7 o/ s# J  H; w4 M. t$ h% s) `5 m
58.                                         printf("ack:%s\r\n",(u8*)ack);
    " c/ v1 J8 h  a4 d
59.                                 
    
60.                                         break;
    
61.                                 }
    
62.                                         USART3_RX_STA=0;
    
63.                         }
    
64.                 }
    
65.                 if(waittime==0)res=1;
    # I  P4 _9 u/ \7 y8 E
66.         }
    
67.         return res;
    
68. }
    
69. 
    
70. 
    
71. //检测是否应答指令
    
72. u8* esp8266_check_cmd(u8 *str)
    4 `& k# N% `2 R5 N8 J# P
73. {
    
74.         char *strx=0;
    
75.         if(USART3_RX_STA&0X8000)               
    ' ?6 ?. d* }% Z% d4 z" ?6 s9 ^
76.         {
    " |$ [& Z. U% \$ [# _2 w; r
77.                 USART3_RX_BUF[USART3_RX_STA&0X7FFF]=0;
    " x& e3 r( @7 K6 i8 V
78.                 strx=strstr((const char*)USART3_RX_BUF,(const char*)str);
    
79.         }
    
80.         return (u8*)strx;
    
81. }
    - e$ r* ]% ?7 G" w0 t2 C7 S
82. 
    
83. 
    * p8 ^1 E+ g! w5 S; S  @& b+ `2 ]6 ?
84. //向ESP8266发送指令（数据）的函数，暂时用不到，可以自己斟酌加上
    
85. //u8* esp8266_send_data(u8 *cmd,u16 waittime)
    
86. //{
    
87. 
    
88. //        char temp[5];
    
89. //        char *ack=temp;
    : \' L3 W0 A- u( J- |
90. //        USART3_RX_STA=0;
    
91. //        u3_printf("%s",cmd);        
    
92. //                LCD_ShowString(30,130,200,16,16,cmd);        
    
93. //        if(waittime)               
    
94. //        {
    
95. //                while(--waittime)        
    8 L/ \* Q5 a: W- @) R! s0 j/ t
96. //                {
    # E9 m/ ?: r; I  ]
97. //                        delay_ms(10);
    4 H* O8 g/ f9 H
98. //                        if(USART3_RX_STA&0X8000)
    
99. //                        {
    ( G- L. X% z& t! |
100. //                                USART3_RX_BUF[USART3_RX_STA&0X7FFF]=0;
     
101. //                                ack=(char*)USART3_RX_BUF;
     8 u& \$ Y  X% {3 K7 ^' ^
102. //                                printf("ack:%s\r\n",(u8*)ack);
     
103. //                        LCD_ShowString(30,190,200,16,16,(u8*)ack);        
     / ]" w9 `6 }- \, ^
104. //                                USART3_RX_STA=0;
     
105. //                                break;
     
106. //                        }
     
107. //                }
     
108. //        }
     " I  Y) r# |3 y3 ^, L4 p$ ^
109. //        return (u8*)ack;
     
110. //}

复制代码

4 P0 k3 @0 f% H, T* Q4 z) V: }, t. _主函数：

1. #include "delay.h"
   
2. #include "sys.h"
   6 N, T( x1 ?: y& J; h7 v
3. #include "usart.h"
   
4. #include "usart3.h"
   . O0 [( L8 H" P0 m& ^
5. #include "esp8266.h"
   * z" I5 d5 ^( B+ F) t
6. #include "string.h"
   
7. #include "timer.h"
   3 \2 z- K. B8 z4 U
8. #include "led.h"
   2 r- F' o( I# W# e
9. 
   1 n. r9 p2 Y$ ^  `7 T; M0 D7 w7 O; f# Y
10. 
    # T) g* b6 ^' K
11. int main(void)
    $ y. n' O' d( q0 u: R
12. {        
    ( r! q! n1 N9 m. D! ~
13.         char a[15];         
    
14.         delay_init();                                               
    
15.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);                        
    
16.         uart_init(115200);                                 
    ) x0 ^% E5 ]6 X5 H2 b( E
17.         usart3_init(115200);         
    
18.         LED_Init();  
    
19.         esp8266_start_trans();                //ESP8266初始化                        
    1 L. ?2 c- d$ C+ w% i7 D
20. 
    % L7 N# t1 k5 B' ]7 H% K
21.          while(1)
    
22.         {
    
23.         if(USART3_RX_STA&0x8000)
    
24.                 {
    ) o+ k" t( U, Z
25.                     sprintf(a,"%s",USART3_RX_BUF);
    
26. 
    
27.                         if(strstr((const char*)a,"on")) //输入on，LED0亮
    
28.                                 LED0=0;
    ( T) _! k1 U  m( r
29.                         if(strstr((const char*)a,"off")) //输入off，LED0灭
    
30.                                 LED0=1;        
    
31.         
    - \4 }4 }5 u, A3 o/ |/ s: U
32.                         USART3_RX_STA=0;
    
33.                         
    
34.                         
    1 o- V$ Z5 _. O4 R7 B
35.         }
    
36. }
    9 A) h' d/ O( e3 k
37. }
    

复制代码

三、结果实现流程与展示
1 Z( I" e: j" I7 Q$ k下面如何用手机实现控制呢？
) a2 z, @4 A, x
1、首先在手机端下载一个TCP，在各大浏览器搜索就有了
. a7 V& L. C6 E

/ B5 a4 F! g; T8 ?1 F6 |
" {: c% I/ I3 L2 C; W2、打开WiFi，搜索你设置的热点并连接
- J( c6 R$ n( ]# v
4 v# d& @+ N3 @9 S* ^7 u
9 u6 N9 W8 |# r; V" w/ N; i
3、查看该WiFi的地址


7 R; u% k! F, E6 v9 S2 u4 R% O
" H- ?; k$ Z0 r& V这里可能会有一定的误差错误，可能会是192.168.4.1，好像要正确的我是去串口调试助手查了一下，跟这里又不太一样，具体原因我也不太了解，如果手机上显示的IP地址不对，那就只能利用调试助手进行一下AT指令查询，这样比较准确，就把串口更改一下就行了（记得代码串口也要更改，自己尝试上手比较有收获）。
; z1 C/ U& D' _' g- B! @
4、打开TCP，输入地址和端口，连接上热点，然后就可以进行各种命令了

结果：

输入on

6 P" u5 [6 Z  J# r: U, {
+ d  }' a( o  b5 S$ ~, W
( t3 w/ L' x3 x  e 输入off
9 ~6 q6 F1 @7 [( Y6 S$ Z

+ D0 i8 I* |% J
四、总结
哈哈，学到这里就会发现你已经轻松掌握了如何使用ESP8266WiFi串口模块了，那么接下来就是对所学知识的巩固与实践操作，再然后就是利用该模块进阶完成各种设计


1 [+ w0 B6 R* h