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

一、ESP8266介绍
互联网+时代，无线传输、无线通信尤为重要，那么在WiFi通信方面就数ESP8266用的最为广泛了，因为ESP8266是一个具备高性能的模块，在不了解其原理的情况下，只要有一定的串口知识理解，那么就可以轻松上手该模块，进而实现手机WiFi操作。简单来说，就是利用编程来实现WiFi模块的透明传输。


4 b: {, p5 L! x8 m7 U' k2 s
# t; ]/ _2 |' o 这里我们看到该模块有8个接口，但是实际上我们只需要用到五个接口就可以操作这个WiFi模块了，主要是3.3V、GND、RXD、TXD、EN这五个接口可以看上图，RXD接单片机上的TXD接口（这里我用的是串口3，所以接PB10），TXD接单片机上的RXD接口（即PB11），EN接3.3V即可。

那么他有哪些指令呢？
) Y* V5 M# y* ^& f% x0 }
这里你会发现它有三种模式即STA、AP、混合，那么我们该如何使用呢，这里简单说明一下
$ i& f9 ]6 M  I- _0 e
' w* ^+ `' ~! USTA模式就是类似一个接收模式，就是开启该模式后，你只能通过串口给他发送信息，ESP8266只负责接收，而不会产生一个热点，（手机或其他设备是找不到热点的）然后这模式我一般会直接用来调试各种AT指令，通过串口调试助手进行数据传输

2 I$ ]3 h. g1 i! X3 L; pAP模式就简单了，就是它发出去一个热点，供手机或其他设备连接，如果要实现手机连热点来控制单片机，那么该模式就要开启了。

0 n4 t) e  {2 @+ v) G% Z混合模式就是两者同时实现。
" z( I0 j* e  J: J; x
接下来关于传输的方式，一般都是采用透传比较好，如果不采用透传模式，那么每发送一次数据都要发送一次AT+CIPSEND=<param>的指令就显得尤为麻烦，因此模式一般设置为透传模式，退出透传模式就给指令“+++”即可，后面代码里也有具体涉及到透传模式的退出操作，后面代码再一一介绍。
$ w) d* n$ |8 t! i6 R6 q5 w
二、如何实现WiFi传输？代码详解附上
串口3初始化函数：
( K1 h( G8 u" P2 ?4 D

1. #include "delay.h"
   * y1 e4 X+ D# r
2. #include "usart3.h"
   
3. #include "stdarg.h"                  
   
4. #include "stdio.h"                  
   , H; j9 X( r6 T4 `0 P* S3 ?
5. #include "string.h"         
   1 R: U2 X' F" X3 \' k% h- H
6. #include "timer.h"
   
7. 
   
8.         u8 res;        
   $ x+ U% m7 C8 J
9. //串口接收发送缓存区               
   ! M5 |* u: B+ ?$ J$ H
10. u8 USART3_RX_BUF[USART3_MAX_RECV_LEN];                        
    
11. u8  USART3_TX_BUF[USART3_MAX_SEND_LEN];                 
    : G- H; \4 r: D  [9 f+ z
12. 
    6 h, }$ q. o. x# g: v+ h
13. 
    
14. 
    
15. vu16 USART3_RX_STA=0;           
    
16. 
    
17. //串口3中断
    0 u; |+ r+ m4 [" F
18. void USART3_IRQHandler(void)
    & F% R) K8 e, @" |6 I5 g
19. {
    
20. 
    : e8 n' d9 y( Z; P; A2 h7 Z
21.         if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
    
22.         {         
    
23.                 res =USART_ReceiveData(USART3);                 
    $ J& H  H' ]; [
24.                 if((USART3_RX_STA&(1<<15))==0)
    - A, X. }$ |1 B, u! i) t
25.                 {
    
26.                         if(USART3_RX_STA<USART3_MAX_RECV_LEN)        
    
27.                         {
    4 F6 ]8 C$ q+ t: [3 D1 A& G
28.                                 TIM_SetCounter(TIM7,0);                                         
    
29.                                 if(USART3_RX_STA==0)                                 
    & B; e+ T* ]8 U$ Y+ n' g
30.                                 {
    7 f* @* a( {+ i) ]9 j
31.                                         TIM_Cmd(TIM7,ENABLE);
    
32.                                 }
    & O/ X6 ]2 _( ]9 Z4 N$ d
33.                                 USART3_RX_BUF[USART3_RX_STA++]=res;        
    * w; t: ]& Q4 z3 F
34.                         }else
    * E5 i7 c; [9 u2 z, [' m" D5 i
35.                         {
    
36.                                 USART3_RX_STA|=1<<15;                        
    $ K$ a4 b+ [' m5 Y
37.                         }
    
38.                 }
    % T' e% A! S9 y, W  b( w, n2 c6 v8 J5 [
39.         }                                                                                                                           
    - ~3 k, e! D) k: ?
40. }   
    
41. 
    $ ?$ n$ @) S) ]! L
42. //串口3初始化
    6 N) M/ ?5 Z2 b) V# f
43. void usart3_init(u32 bound)
    
44. {  
    
45. 
    
46.         NVIC_InitTypeDef NVIC_InitStructure;
    ( W  F& e( S( g) b8 U7 g
47.         GPIO_InitTypeDef GPIO_InitStructure;
    
48.         USART_InitTypeDef USART_InitStructure;
    
49. 
    2 B2 {0 Z  f5 z& w  t* k4 {+ Q& D( Y
50.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);        
      ~# w" G  ^$ D- R1 ~  u
51.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3,ENABLE);
    " I/ j. E1 |' @3 C/ Q  `
52. 
    ' n6 n5 F# t; E: R" K# }
53.          USART_DeInit(USART3);
    
54.                  //USART3_TX   PB10
    
55.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
      t( q: a: F) e3 {5 N" J7 t. x
56.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    5 ~3 Z7 V. h8 {& _& `
57.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    ( z4 E+ q  S: n! M0 l
58.   GPIO_Init(GPIOB, &GPIO_InitStructure);
    
59. 
    
60.     //USART3_RX          PB11
      f+ Z, A/ F- P$ W1 X0 D1 Z$ E! u
61.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
    
62.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
63.   GPIO_Init(GPIOB, &GPIO_InitStructure);
    1 a3 o# I3 @8 x: G6 s* i
64.         
    , }: k2 b) |! ?" K2 a& ]# c
65.         USART_InitStructure.USART_BaudRate = bound;
    3 a: L7 j5 l+ _: Q- w& f
66.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    ) r; k) ~  l! x5 N; F
67.         USART_InitStructure.USART_StopBits = USART_StopBits_1;
    ( X* L, d& B/ f7 l! ?( |, S0 v
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);
    , F% a# C7 a+ Z; J
73. 
    7 F  O! U2 E( G/ b1 O
74. 
    . x# `* d$ m5 ^, q3 i
75.         USART_Cmd(USART3, ENABLE);              
    5 Q# }8 b! `& f% a
76.         
    ) {8 r2 M3 ]" {" O" U: R8 @. f
77. 
    
78.   USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);
    
79.         
    
80. 
    
81.         NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
    
82.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2 ;
    / Q5 i1 O( {# H3 o" t
83.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;               
    
84.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        
    ' i& O/ V4 K5 n! `( J8 T
85.         NVIC_Init(&NVIC_InitStructure);        
    
86.         
      N* [7 U- e8 T7 ~5 {
87.         
    1 m8 f; O) d0 T9 B
88.         TIM7_Int_Init(1000-1,7200-1);               
    
89.         USART3_RX_STA=0;               
    3 g1 v; N0 Q' m- Y& C( Z# ~
90.         TIM_Cmd(TIM7,DISABLE);                        
    # c! c, g1 H) ?+ M- V# ]. v% s% o
91. 
    - c( f7 J1 q0 R* x% M- i% ~& D
92. }
    9 l# z- V1 V/ t( V& a4 `
93. //串口3printf函数，保证输入不大于设定长度
    
94. void u3_printf(char* fmt,...)  
    
95. {  
    
96.         u16 i,j;
    . `1 T" I+ I& P9 c8 K; V
97.         va_list ap;
    
98.         va_start(ap,fmt);
    
99.         vsprintf((char*)USART3_TX_BUF,fmt,ap);
    : b6 D7 S0 f# v3 w  J7 p
100.         va_end(ap);
     " M# u# Z  \! f& Y( s
101.         i=strlen((const char*)USART3_TX_BUF);               
     
102.         for(j=0;j<i;j++)                                                
     9 t2 b' }, j8 M* s% Q# }
103.         {
     
104.           while(USART_GetFlagStatus(USART3,USART_FLAG_TC)==RESET);
     / t, t) F7 C0 X
105.                 USART_SendData(USART3,USART3_TX_BUF[j]);
     
106.         }
     
107. }
     

复制代码

ESP8266初始化函数：

1. #include "esp8266.h"
   & N3 X0 B" a% n# z4 C
2. #include "string.h"
   
3. #include "usart.h"
   
4. #include "usart3.h"
   1 i; h4 F1 A: M4 G4 X
5. #include "stm32f10x.h"
   / m- F3 Y  c6 i8 `! X6 J
6. #include "sys.h"
   4 o" K3 E% E' @, ~, x, U
7. #include "delay.h"
   
8. #include "lcd.h"
   - `+ Y& |8 i# f. B+ P9 u
9. 
   ! G/ H+ t, p( V- E; N+ p5 R
10. //ESP8266初始化
    : ~) V+ m' `# F6 {8 G% I
11. void esp8266_start_trans(void)
    5 K( D5 i8 B# F' u6 Q( d8 v
12. {
    
13.         
    9 l$ I* s0 q- e; B/ @, r& F) m
14.         esp8266_send_cmd("AT+CWMODE=2","OK",50);//设置为AP模式
    / q2 C8 a# d! {  u8 S( N  X6 c- n
15. 
    
16.         esp8266_send_cmd("AT+RST","ready",20);//重启
    1 a0 ~; E. j; }. D$ N
17.         
    
18.         delay_ms(1000);      
    
19.         delay_ms(1000);
    * w6 J7 z  P, A, D
20.         delay_ms(1000);
    
21.         delay_ms(1000);
    & m( n0 ]+ k- z
22.         
    
23.         esp8266_send_cmd("AT+CWSAP="ESP8266","12345678",1,4","OK",200);//设置WiFi名称、密码，模式
    
24.         esp8266_send_cmd("AT+CIPMUX=1","OK",20);//进入透传模式
    
25.         esp8266_send_cmd("AT+CIPSERVER=1,8080","OK",200);//设置端口8080
    
26.         esp8266_send_cmd("AT+CIPSEND","OK",50);//开始发送数据
    
27. }
    
28. 
    
29. //退出透传模式
    ( n2 V' I" S) N$ ]
30. u8 esp8266_quit_trans(void)
    
31. {
    
32.         u8 result=1;
    $ K4 c& Z8 h" D/ ]8 s) |2 F
33.         u3_printf("+++");
    
34.         delay_ms(1000);                                       
      Y9 l6 R4 x# E$ M7 i5 {
35.         result=esp8266_send_cmd("AT","OK",20);
    
36.         if(result)
    ; @* I8 c8 T8 W$ U7 k; s) I0 B
37.                 printf("quit_trans failed!");
    : t9 X8 [: a& q6 j3 H
38.         else
    
39.                 printf("quit_trans success!");
    * p. R" M2 i6 T4 @- a' f. o, r/ k
40.         return result;
    
41. }
    # U' @) I/ u$ B) }+ d- w
42. 
    
43. //发送指令，返回0发送成功，1则失败
    
44. u8 esp8266_send_cmd(u8 *cmd,u8 *ack,u16 waittime)
    6 P( P7 I( k# ]! d4 n& z( K
45. {
    - Q( g6 b6 C6 [& L5 x6 H* r  }2 a
46.         u8 res=0;
    
47.         USART3_RX_STA=0;
    
48.         u3_printf("%s\r\n",cmd);        
    
49.         if(ack&&waittime)               
    8 m( V! Y: {+ S( n
50.         {
    
51.                 while(--waittime)        
    
52.                 {
    ' ^/ v9 r; v/ p4 R# E
53.                         delay_ms(10);
    
54.                         if(USART3_RX_STA&0X8000)
    
55.                         {
    0 d) m5 _4 ]2 [
56.                                 if(esp8266_check_cmd(ack))
    
57.                                 {
    
58.                                         printf("ack:%s\r\n",(u8*)ack);
    
59.                                 
    . D$ g, Y8 {: \* A4 d
60.                                         break;
    - {: V" R7 Z. x( r4 K! s
61.                                 }
    
62.                                         USART3_RX_STA=0;
    
63.                         }
    
64.                 }
    
65.                 if(waittime==0)res=1;
    ) k/ G& T) ]; N! n
66.         }
    ' p1 {( J- h$ X
67.         return res;
    
68. }
    
69. 
    ; _, x" F3 G  j( F1 v! K# E
70. 
    
71. //检测是否应答指令
    
72. u8* esp8266_check_cmd(u8 *str)
    - W, c/ O& c; O% I
73. {
    
74.         char *strx=0;
    
75.         if(USART3_RX_STA&0X8000)               
    # z" ?- n) C/ V
76.         {
    " t2 q* r7 N0 C: K
77.                 USART3_RX_BUF[USART3_RX_STA&0X7FFF]=0;
    
78.                 strx=strstr((const char*)USART3_RX_BUF,(const char*)str);
    
79.         }
    
80.         return (u8*)strx;
    
81. }
    
82. 
    
83. 
    
84. //向ESP8266发送指令（数据）的函数，暂时用不到，可以自己斟酌加上
    
85. //u8* esp8266_send_data(u8 *cmd,u16 waittime)
    
86. //{
    , Q& S$ P  P" p; x8 j2 w' t
87. 
    & [$ d- J: n+ D5 o+ D3 R
88. //        char temp[5];
    ( _; x) A5 A6 V1 C- @5 W3 h1 ~
89. //        char *ack=temp;
    ' E! \8 I, v5 o  T
90. //        USART3_RX_STA=0;
    * X0 Y/ S7 y* t8 K# {
91. //        u3_printf("%s",cmd);        
    3 j# g2 Y) `: n* e$ ?& ?4 e4 q
92. //                LCD_ShowString(30,130,200,16,16,cmd);        
    
93. //        if(waittime)               
    . Z, t5 ^( t2 g5 e" J% n: d+ P" ^
94. //        {
    : W4 h- U  s0 G0 p0 k" q% f( Z
95. //                while(--waittime)        
    + H/ X7 z3 t- v: M. ~2 W3 A: |
96. //                {
    1 }; o9 J0 N. N. O
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;
     4 d9 Q: e0 _- S9 Z
102. //                                printf("ack:%s\r\n",(u8*)ack);
     
103. //                        LCD_ShowString(30,190,200,16,16,(u8*)ack);        
     0 I0 p8 ]1 v1 H& n' m
104. //                                USART3_RX_STA=0;
     
105. //                                break;
     6 |% m0 X; O# r  |' A: E6 p6 ~- a
106. //                        }
     
107. //                }
     
108. //        }
     
109. //        return (u8*)ack;
     % y' `, |: p$ h) E
110. //}

复制代码

1 X/ C8 {' J7 s6 z  B4 U3 `" O主函数：

: c+ d7 |5 n2 v$ V! U! z% v

1. #include "delay.h"
   6 y! T9 @" s: i6 D. y- e4 ]1 |
2. #include "sys.h"
   9 b; A  T  y4 q' t( O4 I' N1 \
3. #include "usart.h"
   " w2 ^% }' s& B4 D
4. #include "usart3.h"
   
5. #include "esp8266.h"
   
6. #include "string.h"
   
7. #include "timer.h"
   
8. #include "led.h"
   
9. 
   
10. 
    0 |, f" g3 e* i/ h4 q
11. int main(void)
    & x* ]( R; ?) j- i( ~6 }2 ^
12. {        
    
13.         char a[15];         
    % t* }$ R0 x, S* d: C
14.         delay_init();                                               
    2 d+ m) @/ z( x
15.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);                        
    
16.         uart_init(115200);                                 
    1 M! x- J# P8 ]3 y7 V# I4 u' p8 M
17.         usart3_init(115200);         
    1 z9 r1 U$ r% O" }! m! D
18.         LED_Init();  
    & m1 w% P+ s' x$ D$ p! _  T
19.         esp8266_start_trans();                //ESP8266初始化                        
    , m( D; p% s. {6 \- P
20. 
    
21.          while(1)
      V* V. T# ~% B8 ]
22.         {
    
23.         if(USART3_RX_STA&0x8000)
    
24.                 {
    
25.                     sprintf(a,"%s",USART3_RX_BUF);
    
26. 
    6 T. k4 E4 h! a2 n+ g/ O! u
27.                         if(strstr((const char*)a,"on")) //输入on，LED0亮
    
28.                                 LED0=0;
    % M+ r; O) J. e3 K: H
29.                         if(strstr((const char*)a,"off")) //输入off，LED0灭
    
30.                                 LED0=1;        
    5 }: ~+ v- ?5 C8 `3 C8 d
31.         
    ! _/ f' c/ |  K5 N- F0 J
32.                         USART3_RX_STA=0;
    . b8 \. ]+ X" O; v( h+ b6 T
33.                         
    
34.                         
    % r3 G6 N5 a4 |5 o4 z
35.         }
    
36. }
    
37. }
    

复制代码

三、结果实现流程与展示
2 M6 l& u5 A& j' s# U& C/ Z下面如何用手机实现控制呢？

1、首先在手机端下载一个TCP，在各大浏览器搜索就有了
4 \9 h! Z0 I. n" |: ]  t

4 g* s; Q. E6 a
# }7 @9 d+ E: B5 v2、打开WiFi，搜索你设置的热点并连接

6 |& B% S" X1 t& l- `7 s

  C$ [9 N+ i' o8 j0 `4 S' J3、查看该WiFi的地址
/ r3 H+ ]( Y  d1 ^7 R  C
; ^/ ]& n/ K( n+ A7 w

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

9 e0 h  |7 i4 @9 I* E4、打开TCP，输入地址和端口，连接上热点，然后就可以进行各种命令了
+ d  \+ a; M+ W: I7 h
结果：
, Y4 R1 t/ t) A& ~8 E- V
输入on

' ~( ^2 _0 ~8 M1 N9 i
' R) n$ t& [' n$ P5 z' m3 a
  u1 F: Z& c) E/ E 输入off
  O, E* R1 d0 V' F$ S! I! [" k

' l" l- E9 q0 ~% R2 r7 ?: @
$ C  F9 v  u2 @. n四、总结
哈哈，学到这里就会发现你已经轻松掌握了如何使用ESP8266WiFi串口模块了，那么接下来就是对所学知识的巩固与实践操作，再然后就是利用该模块进阶完成各种设计
. |% E) ?( M9 V: o7 |
( a- O/ s. u( l/ p; _5 A
2 M1 _- Y" E% G7 S/ @