前言
  Z5 X7 M! o6 o6 E今天这一讲注意涉及到WiFi模块ESP8266的使用，主要是用WiFi来控制LED0亮灭，包括会详细介绍一下该模块的使用，废话不多说，正题进入···
# ?6 [* O5 b0 ~$ {. S3 t
0 l+ ~6 A( u7 u$ A一、ESP8266介绍
互联网+时代，无线传输、无线通信尤为重要，那么在WiFi通信方面就数ESP8266用的最为广泛了，因为ESP8266是一个具备高性能的模块，在不了解其原理的情况下，只要有一定的串口知识理解，那么就可以轻松上手该模块，进而实现手机WiFi操作。简单来说，就是利用编程来实现WiFi模块的透明传输。

! v: K5 m& F8 |7 k5 F

这里我们看到该模块有8个接口，但是实际上我们只需要用到五个接口就可以操作这个WiFi模块了，主要是3.3V、GND、RXD、TXD、EN这五个接口可以看上图，RXD接单片机上的TXD接口（这里我用的是串口3，所以接PB10），TXD接单片机上的RXD接口（即PB11），EN接3.3V即可。

那么他有哪些指令呢？
: ]& f7 a% ?/ |' Q+ O2 N; q& V# n8 _
这里你会发现它有三种模式即STA、AP、混合，那么我们该如何使用呢，这里简单说明一下
9 A5 B4 D% Y, `# y+ A+ g" S4 w
. Z: Z, V7 c3 [: ~& p' \1 g" R" ?STA模式就是类似一个接收模式，就是开启该模式后，你只能通过串口给他发送信息，ESP8266只负责接收，而不会产生一个热点，（手机或其他设备是找不到热点的）然后这模式我一般会直接用来调试各种AT指令，通过串口调试助手进行数据传输
5 a" u* G8 t. J4 x1 Z# z
AP模式就简单了，就是它发出去一个热点，供手机或其他设备连接，如果要实现手机连热点来控制单片机，那么该模式就要开启了。

, K0 p/ V' e0 J混合模式就是两者同时实现。
8 U; y( e* p4 \% N
" L6 L0 f7 l2 Z' b& `6 \9 n5 V接下来关于传输的方式，一般都是采用透传比较好，如果不采用透传模式，那么每发送一次数据都要发送一次AT+CIPSEND=<param>的指令就显得尤为麻烦，因此模式一般设置为透传模式，退出透传模式就给指令“+++”即可，后面代码里也有具体涉及到透传模式的退出操作，后面代码再一一介绍。
. H4 \4 R) B" C% w
二、如何实现WiFi传输？代码详解附上
, O0 m( _" P& u9 D* ]4 V串口3初始化函数：

1. #include "delay.h"
   . l8 u. |+ F8 `! c/ A2 |4 z. |
2. #include "usart3.h"
   
3. #include "stdarg.h"                  
   : J1 j! B) v/ F* M# p! L
4. #include "stdio.h"                  
   ' F+ Z% A' _, \. w# T) x
5. #include "string.h"         
     Y+ n& r- K; L" J8 \
6. #include "timer.h"
   
7. 
   
8.         u8 res;        
   2 K- k+ x6 x2 i/ N2 l! K- B
9. //串口接收发送缓存区               
   7 M7 Q% o2 {3 d; b. W, F) c" J( Q$ A
10. u8 USART3_RX_BUF[USART3_MAX_RECV_LEN];                        
    
11. u8  USART3_TX_BUF[USART3_MAX_SEND_LEN];                 
    
12. 
    
13. 
    
14. 
    
15. vu16 USART3_RX_STA=0;           
    
16. 
    
17. //串口3中断
      M, t* `8 Z8 ?5 m2 B' ]& v- H# b4 w1 d
18. void USART3_IRQHandler(void)
    
19. {
    ; ~& p5 [( S) I; V8 A0 I# ?' S
20. 
    , T  f6 \. h  o& s* i
21.         if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
    
22.         {         
    
23.                 res =USART_ReceiveData(USART3);                 
    
24.                 if((USART3_RX_STA&(1<<15))==0)
    , G, G1 r1 O* a9 f8 ^5 z0 x
25.                 {
    & _3 ?# \: s) C+ J6 |
26.                         if(USART3_RX_STA<USART3_MAX_RECV_LEN)        
    % R5 b) l# i/ N: G8 U9 p" b
27.                         {
    ( E1 u7 K% |" ?5 @
28.                                 TIM_SetCounter(TIM7,0);                                         
    
29.                                 if(USART3_RX_STA==0)                                 
    . B5 r6 b, P1 |" f' K( v
30.                                 {
    
31.                                         TIM_Cmd(TIM7,ENABLE);
    
32.                                 }
    - K! h5 R8 E9 G6 X; A
33.                                 USART3_RX_BUF[USART3_RX_STA++]=res;        
    
34.                         }else
    3 p) {5 v; O& L  t+ M7 X# T
35.                         {
    
36.                                 USART3_RX_STA|=1<<15;                        
    : x- `* J; N9 e5 W# ?: \
37.                         }
    
38.                 }
    
39.         }                                                                                                                           
    
40. }   
    ) y. i2 q: f/ [8 X- s. ^5 s  }8 F
41. 
    ! f" ?) e! Y+ a, c  N
42. //串口3初始化
    
43. void usart3_init(u32 bound)
    
44. {  
    
45. 
    
46.         NVIC_InitTypeDef NVIC_InitStructure;
    # f! E& R2 s: J. T2 `! f1 Q' J
47.         GPIO_InitTypeDef GPIO_InitStructure;
    
48.         USART_InitTypeDef USART_InitStructure;
    5 ]2 q2 R4 R8 B+ r! T7 W2 R6 C  h
49. 
    3 W. B, g$ a) Z' y' o' Z* ~( }
50.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);        
    
51.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3,ENABLE);
    
52. 
    # c+ O+ n; X0 G
53.          USART_DeInit(USART3);
    # N; e" o$ d6 G! T  P
54.                  //USART3_TX   PB10
    
55.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    
56.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    1 u* H8 m2 `( l1 r# g5 t
57.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    0 Y2 ^0 `; q$ F8 J6 t# E; X
58.   GPIO_Init(GPIOB, &GPIO_InitStructure);
    
59. 
    
60.     //USART3_RX          PB11
    $ x! d4 F; P5 S. b/ ^
61.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
    + ^. Q% |' j0 G. r
62.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    . c. z. U. Q: Q# d6 x5 W) t
63.   GPIO_Init(GPIOB, &GPIO_InitStructure);
    
64.         
    
65.         USART_InitStructure.USART_BaudRate = bound;
    " R: N4 W, Q8 u5 `9 b, E
66.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    & U1 j7 Z8 M& O0 q
67.         USART_InitStructure.USART_StopBits = USART_StopBits_1;
    2 T5 E( I6 N6 o
68.         USART_InitStructure.USART_Parity = USART_Parity_No;
    8 ?2 J& ?8 N. x) B- o
69.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    + U+ W' U& E1 {% O# J. B
70.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        
    . R% |) L- h0 I# y( i8 R4 n
71. 
    / X2 A8 ~3 b% R! c9 h
72.         USART_Init(USART3, &USART_InitStructure);
    5 ^5 k3 _7 n; |7 H% R
73. 
    5 J- j) d: J  T6 O
74. 
    ' t$ X( s2 @5 {, O- o3 Z9 B- |
75.         USART_Cmd(USART3, ENABLE);              
    8 b' Z) \, f: Y. s
76.         
    
77. 
    
78.   USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);
    ! ^% F0 }; N/ [
79.         
    
80. 
    
81.         NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
    
82.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2 ;
    
83.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;               
    
84.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        
    ) z$ S1 [$ j2 T5 E. A' B  `( e
85.         NVIC_Init(&NVIC_InitStructure);        
    . {3 e4 w: a/ n
86.         
    
87.         
    * T1 o- w* p- E# K! j6 l$ ~$ l
88.         TIM7_Int_Init(1000-1,7200-1);               
    
89.         USART3_RX_STA=0;               
    3 ~! y* ?$ e6 A; N. ^" m
90.         TIM_Cmd(TIM7,DISABLE);                        
    # z' O" O6 C! X+ p7 i3 J
91. 
    
92. }
    . C5 ~( K; ]/ p  |( u( q1 Y' B
93. //串口3printf函数，保证输入不大于设定长度
    
94. void u3_printf(char* fmt,...)  
    
95. {  
    ; z6 \( S) R1 z* ?( x( H
96.         u16 i,j;
    0 d& B6 f, g* m; A
97.         va_list ap;
    0 Q6 b; ^# z. d9 q$ k$ o' W6 d: C9 X
98.         va_start(ap,fmt);
    
99.         vsprintf((char*)USART3_TX_BUF,fmt,ap);
    
100.         va_end(ap);
     / g# M# D5 a7 ~" l$ f: S& ?
101.         i=strlen((const char*)USART3_TX_BUF);               
     ' m7 d2 x; U" Q' k
102.         for(j=0;j<i;j++)                                                
       x+ Y3 ?) ?. D, `" {& o* O
103.         {
     " D0 Y: q0 U& B3 c+ m& Y: t( `
104.           while(USART_GetFlagStatus(USART3,USART_FLAG_TC)==RESET);
     $ g# V: ^- h0 _) x  A
105.                 USART_SendData(USART3,USART3_TX_BUF[j]);
     
106.         }
     
107. }
     

复制代码

3 l2 Y# ?; ~% q- O! P, b/ Q. z3 \ESP8266初始化函数：
! H8 ]7 v, n7 z* s# h
, J: u# B6 A  x5 T& n: h) s2 Z

1. #include "esp8266.h"
   
2. #include "string.h"
   
3. #include "usart.h"
   ! ^* \  z/ A( J' ^" |5 f1 y
4. #include "usart3.h"
   , _9 A0 W6 }0 I8 V0 o
5. #include "stm32f10x.h"
   " I7 G! N9 C2 z: `! [( }7 a
6. #include "sys.h"
   
7. #include "delay.h"
   2 r- B1 f! x7 Y0 {! }' `: L6 l7 H3 s
8. #include "lcd.h"
   
9. 
   
10. //ESP8266初始化
    
11. void esp8266_start_trans(void)
    + Y0 `# N. c4 X( L9 N* P
12. {
    
13.         
    
14.         esp8266_send_cmd("AT+CWMODE=2","OK",50);//设置为AP模式
    
15. 
    ; [' ~: r, t7 w# _
16.         esp8266_send_cmd("AT+RST","ready",20);//重启
    " _( m; k" t0 b+ V+ i
17.         
    
18.         delay_ms(1000);      
    & j. ~0 B1 A2 @5 ]% O8 `
19.         delay_ms(1000);
    # W$ d, a4 x. q8 O
20.         delay_ms(1000);
    
21.         delay_ms(1000);
      V8 t% C: p/ l/ q% o9 j6 a1 v
22.         
    9 V& I( L5 L+ n) G: m8 h
23.         esp8266_send_cmd("AT+CWSAP="ESP8266","12345678",1,4","OK",200);//设置WiFi名称、密码，模式
    ( t$ {1 L8 g5 i8 |+ d( \' ~1 F) A
24.         esp8266_send_cmd("AT+CIPMUX=1","OK",20);//进入透传模式
    6 m) `( @1 f& `
25.         esp8266_send_cmd("AT+CIPSERVER=1,8080","OK",200);//设置端口8080
    ! c1 [. r6 p; K) e
26.         esp8266_send_cmd("AT+CIPSEND","OK",50);//开始发送数据
    
27. }
    
28. 
    # V9 P! w0 T$ N2 `# h+ c# ?' y: D
29. //退出透传模式
    
30. u8 esp8266_quit_trans(void)
    
31. {
    / K- K  P; ^0 P& \4 p7 p
32.         u8 result=1;
    % n9 k3 v1 w8 {& V) u5 V) f
33.         u3_printf("+++");
    $ k$ b* P- |7 P7 L
34.         delay_ms(1000);                                       
    
35.         result=esp8266_send_cmd("AT","OK",20);
    $ a# ~- E  m2 z. i
36.         if(result)
    9 C' a. h* ^8 {* [% S& x
37.                 printf("quit_trans failed!");
    
38.         else
    ) P$ U) S5 z1 w1 S8 }& ^# x
39.                 printf("quit_trans success!");
    
40.         return result;
    / G7 i- L& ?# p, k
41. }
    
42. 
    0 P1 X% J; a. z8 R8 D% I9 s
43. //发送指令，返回0发送成功，1则失败
    
44. u8 esp8266_send_cmd(u8 *cmd,u8 *ack,u16 waittime)
    : X$ {! v0 R0 r% U! W( K3 t
45. {
    
46.         u8 res=0;
    5 Q, J9 _# ]2 T: |9 @& _$ g
47.         USART3_RX_STA=0;
    
48.         u3_printf("%s\r\n",cmd);        
    7 H4 J6 a$ s$ y( y" u
49.         if(ack&&waittime)               
    + S% f; Z; O* U, y6 o
50.         {
    * ^: w4 w( ?  n" X1 n' D( D$ Y
51.                 while(--waittime)        
    4 {, N3 z$ M! \3 _6 H
52.                 {
    # D. ?2 L2 i# ~5 T+ m; b, `
53.                         delay_ms(10);
    1 |* Y/ ]; s; S' g5 l2 F
54.                         if(USART3_RX_STA&0X8000)
    - u! x$ H7 n4 C; ~: j% {+ }/ E
55.                         {
    
56.                                 if(esp8266_check_cmd(ack))
    ! L/ @" C7 ~" y1 V* m" g
57.                                 {
    / _' L8 t( T. h" s* k* U
58.                                         printf("ack:%s\r\n",(u8*)ack);
    
59.                                 
    
60.                                         break;
    
61.                                 }
    2 y' D! D" P7 \% p* D
62.                                         USART3_RX_STA=0;
      r, L( h; ]# \4 i. N
63.                         }
    
64.                 }
    $ t! j& {8 J7 {# d- G
65.                 if(waittime==0)res=1;
    
66.         }
    2 Y( y7 \" g$ H4 [
67.         return res;
    
68. }
    4 {$ B, l- b7 e
69. 
    7 j; j. u) ?4 t- e
70. 
    ; D  u2 r; K. v2 c' X
71. //检测是否应答指令
    ! ~2 l9 {( q! B) d) P) j
72. u8* esp8266_check_cmd(u8 *str)
    & C* z8 ~* c  K. g, U0 \- |- \
73. {
    
74.         char *strx=0;
    
75.         if(USART3_RX_STA&0X8000)               
    
76.         {
    4 W5 U, F: w/ J' ^
77.                 USART3_RX_BUF[USART3_RX_STA&0X7FFF]=0;
    
78.                 strx=strstr((const char*)USART3_RX_BUF,(const char*)str);
    
79.         }
    ! F9 w6 a6 y. x2 q7 b; l% Y6 v% F
80.         return (u8*)strx;
    
81. }
    # Q2 Z9 H8 h& Y$ E6 }: ^/ N* y
82. 
    " E- d$ W8 b" `" D( B  _
83. 
    ' p9 w) ]; C: @' ]" K* J
84. //向ESP8266发送指令（数据）的函数，暂时用不到，可以自己斟酌加上
    0 W: R6 @6 m5 S( v7 h2 t
85. //u8* esp8266_send_data(u8 *cmd,u16 waittime)
    
86. //{
    + Y+ [7 E3 \' G4 I+ {, u
87. 
    ( B' V: v# W$ S3 b8 G: ]; M' ]# p
88. //        char temp[5];
    $ _7 d: e* l! u# X, s
89. //        char *ack=temp;
    
90. //        USART3_RX_STA=0;
    / L3 I5 J* v, H. l1 c
91. //        u3_printf("%s",cmd);        
    - S: c5 c! U+ Q/ ]! N
92. //                LCD_ShowString(30,130,200,16,16,cmd);        
    3 E% J1 Z; Z1 [4 G
93. //        if(waittime)               
    ) p& m7 }3 K  p& l- W( D$ E
94. //        {
    " f! M. G8 b- g8 n6 x! I
95. //                while(--waittime)        
    1 F) t* {! _1 e$ W) I% ~6 w$ \
96. //                {
    
97. //                        delay_ms(10);
    
98. //                        if(USART3_RX_STA&0X8000)
    
99. //                        {
    
100. //                                USART3_RX_BUF[USART3_RX_STA&0X7FFF]=0;
     
101. //                                ack=(char*)USART3_RX_BUF;
     
102. //                                printf("ack:%s\r\n",(u8*)ack);
     - F+ W* ]2 S  @3 n: H
103. //                        LCD_ShowString(30,190,200,16,16,(u8*)ack);        
     
104. //                                USART3_RX_STA=0;
     8 K% r% A  L, Q- p
105. //                                break;
       M+ @+ i6 S3 s/ k- }6 X9 U0 S; a! M# _
106. //                        }
     
107. //                }
       K) ~5 P# q  v3 H( b. [
108. //        }
     
109. //        return (u8*)ack;
     : U. b8 H+ m5 y
110. //}

复制代码

+ S5 B" }) _5 y- Y主函数：

1. #include "delay.h"
   
2. #include "sys.h"
   
3. #include "usart.h"
   
4. #include "usart3.h"
   
5. #include "esp8266.h"
   
6. #include "string.h"
   / o. o( f3 s4 e6 ]! i
7. #include "timer.h"
   # t8 N9 O' v3 K- t
8. #include "led.h"
   
9. 
   , c7 Q+ g& B  B+ o
10. 
    : D1 _( ?2 D9 Y! |6 O) R5 T
11. int main(void)
    ; B" |( V  z" H) a! X+ Q! }
12. {        
    9 R' _1 o* E6 _. j% w$ i" _
13.         char a[15];         
    
14.         delay_init();                                               
    
15.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);                        
    
16.         uart_init(115200);                                 
    . K$ h0 }4 u: L: B/ j. N: h
17.         usart3_init(115200);         
    
18.         LED_Init();  
    
19.         esp8266_start_trans();                //ESP8266初始化                        
    
20. 
    0 Y7 i3 B1 t) B
21.          while(1)
    ! t0 _3 Q$ q2 j+ a4 C+ I& n- u$ B' g- e
22.         {
    
23.         if(USART3_RX_STA&0x8000)
    6 k( {; {3 G% y: F* C: a
24.                 {
    
25.                     sprintf(a,"%s",USART3_RX_BUF);
    
26. 
    
27.                         if(strstr((const char*)a,"on")) //输入on，LED0亮
    
28.                                 LED0=0;
    
29.                         if(strstr((const char*)a,"off")) //输入off，LED0灭
    
30.                                 LED0=1;        
    
31.         
      _6 q& G9 z; \
32.                         USART3_RX_STA=0;
    
33.                         
    
34.                         
    & @6 D8 J8 J- N9 d4 m
35.         }
    7 n/ N% T' r. x3 u. G: J4 u# |
36. }
    ; j+ P9 c- X5 d: x
37. }
    . o5 r1 C  X7 ]& ?& e, D0 J

复制代码

6 J1 K/ O' {% i2 a7 P, i4 j, H- E三、结果实现流程与展示
( L( F1 a# G( }7 l) Y5 n& h下面如何用手机实现控制呢？
0 |; V2 h) A* J9 g+ [8 Y
% w' w( J, e' {' |1、首先在手机端下载一个TCP，在各大浏览器搜索就有了
) P# g6 H, n4 s- p) k

" c- H7 j1 T3 N- R1 c$ D
: I% ?; d; X. C. H! ]( R& t2、打开WiFi，搜索你设置的热点并连接
* d( r0 P3 V8 y4 P7 Y

5 m: A: }* o7 c" I2 z* g
( n) u6 ]3 `2 a% b6 S. I3、查看该WiFi的地址

1 a9 j7 b4 F8 Q) W

这里可能会有一定的误差错误，可能会是192.168.4.1，好像要正确的我是去串口调试助手查了一下，跟这里又不太一样，具体原因我也不太了解，如果手机上显示的IP地址不对，那就只能利用调试助手进行一下AT指令查询，这样比较准确，就把串口更改一下就行了（记得代码串口也要更改，自己尝试上手比较有收获）。

- r3 ]7 L: `0 u4 J4、打开TCP，输入地址和端口，连接上热点，然后就可以进行各种命令了
2 f6 }  O# L! k, e  n7 V$ C
; x8 M6 J% t9 k# s1 F- Z: D  d结果：
) P+ K. Q' H$ w) a* o0 W
输入on
* z  j6 r' m9 K% L

9 @$ t. N- H+ Z2 I
( B2 n4 k$ g8 E+ r/ n 输入off
2 `9 z1 V9 b" l, a4 J6 b
9 i% g( W1 S% U! E# v2 u
# {" \* B5 Z8 t1 ]! e0 f  k
* g6 ]& S- s4 H! E四、总结
哈哈，学到这里就会发现你已经轻松掌握了如何使用ESP8266WiFi串口模块了，那么接下来就是对所学知识的巩固与实践操作，再然后就是利用该模块进阶完成各种设计

( S% ?8 a8 D5 U- N2 T1 T