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

4 x+ G8 m8 L; Y% H0 v9 Y2 n- }3 P一、ESP8266介绍
$ e2 I* o9 w3 v7 [互联网+时代，无线传输、无线通信尤为重要，那么在WiFi通信方面就数ESP8266用的最为广泛了，因为ESP8266是一个具备高性能的模块，在不了解其原理的情况下，只要有一定的串口知识理解，那么就可以轻松上手该模块，进而实现手机WiFi操作。简单来说，就是利用编程来实现WiFi模块的透明传输。
* q6 V/ g1 @0 T; E! `
$ `2 H5 `: p) ?4 F4 P9 x- ~
1 H$ q6 N' q& a0 b
" l) G8 b( o0 p! x0 t9 S( M2 R0 ?! s 这里我们看到该模块有8个接口，但是实际上我们只需要用到五个接口就可以操作这个WiFi模块了，主要是3.3V、GND、RXD、TXD、EN这五个接口可以看上图，RXD接单片机上的TXD接口（这里我用的是串口3，所以接PB10），TXD接单片机上的RXD接口（即PB11），EN接3.3V即可。
. p3 l' M0 N/ h. |5 N  ?  u$ V) s- C
* F# a! u# g7 K# h! L那么他有哪些指令呢？
# h9 _$ n0 n8 ?- }$ ~' ^# ]4 }
这里你会发现它有三种模式即STA、AP、混合，那么我们该如何使用呢，这里简单说明一下
2 D3 @* m. a* U& c$ v
. m0 d5 B; Q; o. |: q8 _% k" G3 wSTA模式就是类似一个接收模式，就是开启该模式后，你只能通过串口给他发送信息，ESP8266只负责接收，而不会产生一个热点，（手机或其他设备是找不到热点的）然后这模式我一般会直接用来调试各种AT指令，通过串口调试助手进行数据传输

" B9 d1 O- M# e: IAP模式就简单了，就是它发出去一个热点，供手机或其他设备连接，如果要实现手机连热点来控制单片机，那么该模式就要开启了。

混合模式就是两者同时实现。

6 u- a: `' J0 G3 D9 s3 G) e接下来关于传输的方式，一般都是采用透传比较好，如果不采用透传模式，那么每发送一次数据都要发送一次AT+CIPSEND=<param>的指令就显得尤为麻烦，因此模式一般设置为透传模式，退出透传模式就给指令“+++”即可，后面代码里也有具体涉及到透传模式的退出操作，后面代码再一一介绍。

二、如何实现WiFi传输？代码详解附上
! e% p% [6 f( R: [串口3初始化函数：
$ O) t# y, ]6 L# w0 T, Z0 l

1. #include "delay.h"
   
2. #include "usart3.h"
   
3. #include "stdarg.h"                  
   
4. #include "stdio.h"                  
   
5. #include "string.h"         
   ! D6 |( f% e: {' ]# H
6. #include "timer.h"
   1 N5 \+ h1 \2 k$ Z  R
7. 
   
8.         u8 res;        
   
9. //串口接收发送缓存区               
   
10. u8 USART3_RX_BUF[USART3_MAX_RECV_LEN];                        
    
11. u8  USART3_TX_BUF[USART3_MAX_SEND_LEN];                 
    
12. 
    . }9 {2 ]7 ]4 k0 Y; G, o
13. 
    
14. 
    % N; ^/ J  d4 n  W# D6 T
15. vu16 USART3_RX_STA=0;           
    
16. 
    # s- r* U- S6 ^. Z& x# O9 Q; P
17. //串口3中断
    
18. void USART3_IRQHandler(void)
    1 ?0 g5 ~( k% t+ C* I$ G
19. {
    
20. 
    
21.         if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
    
22.         {         
    
23.                 res =USART_ReceiveData(USART3);                 
    
24.                 if((USART3_RX_STA&(1<<15))==0)
    
25.                 {
    1 F" j* @  W' B6 K' |1 `0 Y# a
26.                         if(USART3_RX_STA<USART3_MAX_RECV_LEN)        
    & o0 p6 n8 g2 f7 `4 s2 C
27.                         {
    
28.                                 TIM_SetCounter(TIM7,0);                                         
    2 H. ^8 s; \% E8 f/ w
29.                                 if(USART3_RX_STA==0)                                 
    
30.                                 {
    ' D: F* P! K5 I. J2 v) s9 d4 z6 p
31.                                         TIM_Cmd(TIM7,ENABLE);
    2 @9 _, i4 Z& [3 H  Q+ R: n# v
32.                                 }
    , T; L9 A- e6 ~8 ?; L
33.                                 USART3_RX_BUF[USART3_RX_STA++]=res;        
    - E( n* n0 Y8 e4 m/ n& r% r
34.                         }else
    2 u$ S1 y% S& T+ d4 p9 D
35.                         {
    + h. f5 w/ M" E6 m# \3 T0 Z, u
36.                                 USART3_RX_STA|=1<<15;                        
    
37.                         }
    
38.                 }
    ) ?) b+ L0 @# ?" Q. w
39.         }                                                                                                                           
    & W0 g( a& y/ @  w1 E
40. }   
    . F# `$ l! N8 O' f
41. 
    : D: k* x3 _6 E% g
42. //串口3初始化
    " H* X" F) N/ ^5 p) j
43. void usart3_init(u32 bound)
    ! Q6 t: F+ \, Z
44. {  
    : s5 A3 C  o: v3 B# H$ _% o
45. 
    - a* q; |' ]* B1 p# x( a/ Z
46.         NVIC_InitTypeDef NVIC_InitStructure;
    
47.         GPIO_InitTypeDef GPIO_InitStructure;
    
48.         USART_InitTypeDef USART_InitStructure;
    * |: w$ j8 E, t; t: a5 |3 i
49. 
    ) N% L! e" ]8 e/ e1 m0 E3 z; M
50.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);        
    ! ^. X  d6 g9 H. [9 d' C
51.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3,ENABLE);
    + d2 Q$ o% e; L
52. 
    * O- c" l" [& u! S' A" L' q" l7 S1 y
53.          USART_DeInit(USART3);
    : }3 H3 `2 ]& j) \6 C- `  s, e
54.                  //USART3_TX   PB10
    9 s4 i$ W# r4 C7 V5 E# }3 Z
55.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    " f" ~5 i* b. {3 b  z0 H
56.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    . u5 R5 z+ K! F; ^0 O
57.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    1 R3 I& c3 o* [# Y- [
58.   GPIO_Init(GPIOB, &GPIO_InitStructure);
    
59. 
    
60.     //USART3_RX          PB11
    7 \/ ]; S& ~% Z' R, S( u
61.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
    ; F- h3 s6 ?/ {( f- I1 ~; r
62.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    ( r- N( }0 {9 \; A: L" D
63.   GPIO_Init(GPIOB, &GPIO_InitStructure);
    % z& P( J. Y, Y2 M
64.         
    / G& ^* X4 c+ e) t& B/ T
65.         USART_InitStructure.USART_BaudRate = bound;
    
66.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    
67.         USART_InitStructure.USART_StopBits = USART_StopBits_1;
    
68.         USART_InitStructure.USART_Parity = USART_Parity_No;
    
69.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    
70.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        
    
71. 
    
72.         USART_Init(USART3, &USART_InitStructure);
    
73. 
    9 z, I# ?2 x1 J8 x7 S
74. 
    5 B. @' a9 @. f3 b: Z& ?: J
75.         USART_Cmd(USART3, ENABLE);              
    2 M+ _5 D7 ^: d& ~
76.         
    
77. 
    6 l/ c9 C- A$ ]5 s5 C( i
78.   USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);
    * `2 `! l" ^# S2 Q) J
79.         
    - T# M& e4 q0 a; i3 V4 B' I
80. 
    
81.         NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
    . k8 D8 z0 M- w" b3 \) Z
82.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2 ;
    
83.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;               
    
84.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        
    ( x7 D2 M7 }7 b# m- K
85.         NVIC_Init(&NVIC_InitStructure);        
    
86.         
    + ^5 y5 @. D' H9 J6 C
87.         
    " a, n8 H! `, ^" J4 {# G) Y4 t  q
88.         TIM7_Int_Init(1000-1,7200-1);               
    9 _( z1 D/ B, X) {5 H" P8 i
89.         USART3_RX_STA=0;               
    
90.         TIM_Cmd(TIM7,DISABLE);                        
    4 O8 s( x( H) N
91. 
    6 F& L2 d0 [& g' |
92. }
    ) M  C7 g' u& f4 L+ s& ~. f5 G) O) K
93. //串口3printf函数，保证输入不大于设定长度
    
94. void u3_printf(char* fmt,...)  
    
95. {  
    
96.         u16 i,j;
    ) R+ M3 C" ~' u4 B, X" E
97.         va_list ap;
    9 X* }) [2 [! D
98.         va_start(ap,fmt);
      d, ?' F/ l0 c- R
99.         vsprintf((char*)USART3_TX_BUF,fmt,ap);
    
100.         va_end(ap);
     
101.         i=strlen((const char*)USART3_TX_BUF);               
     
102.         for(j=0;j<i;j++)                                                
     6 ?2 }# E5 _* h8 \& q% E, [
103.         {
     
104.           while(USART_GetFlagStatus(USART3,USART_FLAG_TC)==RESET);
     
105.                 USART_SendData(USART3,USART3_TX_BUF[j]);
     ' D; e0 B" a4 T( q, t
106.         }
     $ @( ^: A/ K: Q3 e$ c5 |
107. }
     

复制代码

ESP8266初始化函数：
( r! s3 {2 L( S" O/ l

1. #include "esp8266.h"
   
2. #include "string.h"
   
3. #include "usart.h"
   & m( u8 z" V( }9 Z
4. #include "usart3.h"
   / d& O: l6 M: u4 Q  N( j
5. #include "stm32f10x.h"
   
6. #include "sys.h"
   
7. #include "delay.h"
   
8. #include "lcd.h"
   $ s8 w& O, }/ q* Z- c& A4 l
9. 
   + V$ s4 B; Y: V0 _+ ^/ \
10. //ESP8266初始化
    
11. void esp8266_start_trans(void)
    - e8 k) d. X$ E5 G  ~6 `7 H
12. {
    ! G6 }0 e, j% H8 a( |- v' e
13.         
    
14.         esp8266_send_cmd("AT+CWMODE=2","OK",50);//设置为AP模式
    ) \* z0 ~' t7 E- p+ ~
15. 
    
16.         esp8266_send_cmd("AT+RST","ready",20);//重启
    5 h2 X' p8 l" x" F4 r
17.         
    5 U/ Z* l2 ?1 V
18.         delay_ms(1000);      
    
19.         delay_ms(1000);
    
20.         delay_ms(1000);
    
21.         delay_ms(1000);
    ( u* U: V2 k) C1 p# H% f4 I
22.         
    7 `* f; Q* s; Y! R2 W/ v
23.         esp8266_send_cmd("AT+CWSAP="ESP8266","12345678",1,4","OK",200);//设置WiFi名称、密码，模式
      j- m5 [0 [: T+ ^9 ]1 @* Y3 u
24.         esp8266_send_cmd("AT+CIPMUX=1","OK",20);//进入透传模式
    
25.         esp8266_send_cmd("AT+CIPSERVER=1,8080","OK",200);//设置端口8080
    * {, H5 i( o3 i# {+ I. A
26.         esp8266_send_cmd("AT+CIPSEND","OK",50);//开始发送数据
    1 @% I1 n4 R$ D# \: r7 d
27. }
    ' \; r# p" N; q0 S3 R; n
28. 
    
29. //退出透传模式
    ' s! t6 E3 V8 o4 S" ~0 R0 S
30. u8 esp8266_quit_trans(void)
    0 S6 w+ t! s3 d# }8 e) _7 _& m
31. {
      M% E9 b# \. m; m2 Q7 W6 u
32.         u8 result=1;
    
33.         u3_printf("+++");
    
34.         delay_ms(1000);                                       
    1 \1 J  P! P+ y6 t
35.         result=esp8266_send_cmd("AT","OK",20);
    % k4 v9 Q# K" |$ H- s( z$ i# I
36.         if(result)
    : D) s7 i' {3 @
37.                 printf("quit_trans failed!");
    $ n" M: N- W7 ]. p  D* e+ C
38.         else
    % x3 U3 D+ S0 H/ X! @
39.                 printf("quit_trans success!");
    - P4 u, ^6 ]( _- v+ S. J6 M1 O: {
40.         return result;
    
41. }
    
42. 
    : k  |3 w3 i& @3 x( ^2 a
43. //发送指令，返回0发送成功，1则失败
    + A. ^9 r( k& ]8 x8 w0 X, p. q
44. u8 esp8266_send_cmd(u8 *cmd,u8 *ack,u16 waittime)
    5 n0 m8 }% b, @( g+ @/ V
45. {
    
46.         u8 res=0;
    * T1 f) H, ?. p( |! L2 K: ?+ U
47.         USART3_RX_STA=0;
    
48.         u3_printf("%s\r\n",cmd);        
    * E9 Q$ b- w$ m# |: ~
49.         if(ack&&waittime)               
    + Q' A3 G* p+ i1 n8 p
50.         {
    
51.                 while(--waittime)        
    ; H* T  P1 C) ]' n2 H% `
52.                 {
    , Q, |: ~7 |: e: J7 w1 t0 }4 E' l
53.                         delay_ms(10);
    
54.                         if(USART3_RX_STA&0X8000)
    
55.                         {
    
56.                                 if(esp8266_check_cmd(ack))
    
57.                                 {
    
58.                                         printf("ack:%s\r\n",(u8*)ack);
    
59.                                 
    
60.                                         break;
    
61.                                 }
    
62.                                         USART3_RX_STA=0;
    ; N8 X, h9 q# B, m
63.                         }
    
64.                 }
    * \( I* X2 Z8 T& h! j
65.                 if(waittime==0)res=1;
    
66.         }
    ) J5 @" X! D3 ~/ [; k* e2 Z( ?
67.         return res;
    
68. }
    ; a$ j0 [! j3 ~+ [( l. k, }
69. 
    
70. 
    ! J2 O6 a% ?" w9 ]* {% |. V
71. //检测是否应答指令
    # B0 t* n3 C$ D+ x6 k/ U) h
72. u8* esp8266_check_cmd(u8 *str)
    
73. {
    4 }! P# C+ }: W' Y; q- b# l
74.         char *strx=0;
    ( E0 s3 b4 l$ i- J1 F
75.         if(USART3_RX_STA&0X8000)               
    
76.         {
    4 r* Y4 Z' H) |9 B. q- `3 Z  }
77.                 USART3_RX_BUF[USART3_RX_STA&0X7FFF]=0;
    
78.                 strx=strstr((const char*)USART3_RX_BUF,(const char*)str);
    
79.         }
    ! a0 N( a7 _& T* K
80.         return (u8*)strx;
    ) A1 y) o2 p& i/ y1 @* l/ H1 N8 ~
81. }
    " j5 i3 Z& c% r8 u" V
82. 
    ' H, `- N2 G$ B6 Q* I! O
83. 
    
84. //向ESP8266发送指令（数据）的函数，暂时用不到，可以自己斟酌加上
    , o) W0 E' L+ X3 D' I( i) `# n
85. //u8* esp8266_send_data(u8 *cmd,u16 waittime)
    " v; I7 |# b$ V+ H% u8 O$ ]
86. //{
    # J- r: G8 y' L* V
87. 
    ) g- |# Q( k: |2 i  j
88. //        char temp[5];
    
89. //        char *ack=temp;
      \5 A1 j) q) |7 u" l& y
90. //        USART3_RX_STA=0;
    
91. //        u3_printf("%s",cmd);        
    
92. //                LCD_ShowString(30,130,200,16,16,cmd);        
    : a& T  v  c) F7 L" Q! Q
93. //        if(waittime)               
    % X8 r9 A$ a8 G$ X6 Y$ E
94. //        {
    
95. //                while(--waittime)        
    
96. //                {
    
97. //                        delay_ms(10);
    
98. //                        if(USART3_RX_STA&0X8000)
    " O! ?) F5 B3 y9 m# a3 f8 X
99. //                        {
    
100. //                                USART3_RX_BUF[USART3_RX_STA&0X7FFF]=0;
     ; n# x2 X" P) t* |/ s2 k
101. //                                ack=(char*)USART3_RX_BUF;
     7 n, v! t8 @8 f0 ~( ~" n5 m- M, e
102. //                                printf("ack:%s\r\n",(u8*)ack);
     
103. //                        LCD_ShowString(30,190,200,16,16,(u8*)ack);        
     ! o2 [8 B* p8 f4 h$ ~: w
104. //                                USART3_RX_STA=0;
     
105. //                                break;
     
106. //                        }
     
107. //                }
     % D0 A2 A8 c7 e$ v
108. //        }
     " {; p1 B, q, g
109. //        return (u8*)ack;
     7 Y* w/ D* Y) e$ S
110. //}

复制代码

主函数：
. [! U. V/ l3 W# I1 i" Y0 L
" ?$ x& |! n# Q' m* m- h$ P

1. #include "delay.h"
   ( d) X7 v% W+ q9 l. K- L" N& g
2. #include "sys.h"
   
3. #include "usart.h"
   , q5 v9 e: p- S
4. #include "usart3.h"
   4 T! w9 W( K. V. g; @5 c
5. #include "esp8266.h"
   , w& ]/ i9 l3 R  k: _/ C+ I$ J
6. #include "string.h"
   ( F6 t3 o' K9 i
7. #include "timer.h"
   
8. #include "led.h"
   , n: a* w  N6 u3 t% r
9. 
   3 _) d6 C, }* z( z4 u
10. 
    
11. int main(void)
    
12. {        
    4 _6 R' Q3 \. Z
13.         char a[15];         
    
14.         delay_init();                                               
    0 u: k9 z- U" a  P* z' c. G
15.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);                        
    / p1 B. z3 \" p) H
16.         uart_init(115200);                                 
    ) F# ?5 d) l( }2 O$ f
17.         usart3_init(115200);         
    
18.         LED_Init();  
    , }5 i) Q  c( Z: ^1 ]  ?, G' ]
19.         esp8266_start_trans();                //ESP8266初始化                        
    
20. 
    ( _& b  y& I! d! K) t; P3 v  l
21.          while(1)
    3 Y/ p) T- k! [5 j9 s1 U0 q
22.         {
    
23.         if(USART3_RX_STA&0x8000)
    
24.                 {
    # `5 F' c. ~- `% X: c
25.                     sprintf(a,"%s",USART3_RX_BUF);
    2 y3 ?& |1 H8 M3 w" M
26. 
    9 h# h* m: a" V' e7 l4 H0 a! ^& O
27.                         if(strstr((const char*)a,"on")) //输入on，LED0亮
    
28.                                 LED0=0;
    0 m( @( f( w) X$ A
29.                         if(strstr((const char*)a,"off")) //输入off，LED0灭
    
30.                                 LED0=1;        
    
31.         
    + w: A% q% c# e3 `
32.                         USART3_RX_STA=0;
    7 G/ H4 a$ v7 E. h7 ^$ v
33.                         
    
34.                         
    . w" o, z. X) [) n6 V% ^( t
35.         }
    
36. }
      m5 I3 ?' a/ x: y: h
37. }
    & m- d( ]/ M3 o! R" P6 X3 H

复制代码

2 \1 y8 {8 g) Z" `5 {三、结果实现流程与展示
下面如何用手机实现控制呢？

1、首先在手机端下载一个TCP，在各大浏览器搜索就有了
6 |0 a* V. Q7 V

. `' S, j& k! Z7 d9 v& x1 [% i1 {5 T7 R
3 H) |$ I$ l) ~  R2、打开WiFi，搜索你设置的热点并连接
0 _( q- ~5 `6 n/ B7 I/ ~0 s
+ R. Z# R1 }7 x& Y% u7 H2 K4 M% Y0 `
1 {: T5 E/ Z- Q( K9 W5 z
. G3 U4 W- |5 T* l3、查看该WiFi的地址

* G; x4 c% u8 W) ~# m
+ g* G- }+ {8 j! e+ V. N
, u, B  H3 R4 K) `" J0 y3 A这里可能会有一定的误差错误，可能会是192.168.4.1，好像要正确的我是去串口调试助手查了一下，跟这里又不太一样，具体原因我也不太了解，如果手机上显示的IP地址不对，那就只能利用调试助手进行一下AT指令查询，这样比较准确，就把串口更改一下就行了（记得代码串口也要更改，自己尝试上手比较有收获）。
! p1 }' Q6 Z) q. {) Z* P
1 L, c+ r1 f3 M: x6 j4、打开TCP，输入地址和端口，连接上热点，然后就可以进行各种命令了

结果：

! Z9 L$ @" y& F; e: V0 v9 ^2 \输入on
: b7 a0 Y5 ~9 k0 ]# g- Y
0 C" p5 G% R8 f  Q% v
+ v; K6 y  U+ }3 _' ~+ ]; U  ]! f
输入off
. Z& a0 U1 ], h# F) [. P9 S
% n' ~7 B9 U8 W# O, g  }. |
9 }3 w& i( Y! H3 i
四、总结
哈哈，学到这里就会发现你已经轻松掌握了如何使用ESP8266WiFi串口模块了，那么接下来就是对所学知识的巩固与实践操作，再然后就是利用该模块进阶完成各种设计